@gtkx/components 2.0.0-beta.1 → 2.0.0-beta.11

package/src/internal/collection-model.ts

@@ -1,6 +1,8 @@
+import type { ReactNode, Ref } from "react";
 import * as Gio from "@gtkx/gi/gio";
 import * as GObject from "@gtkx/gi/gobject";
 import * as Gtk from "@gtkx/gi/gtk";
+import { createElementComponent } from "@gtkx/react";
 import { registerClass } from "@gtkx/runtime";
 import type { CollectionIndex, Level } from "./collection-index.js";
 import type { TreeExpansion } from "./tree-expansion.js";
@@ -11,7 +13,7 @@ import { adoptIndex, createTreeExpansion, pruneSlots } from "./tree-expansion.js
 type LevelStore = Gio.ListModel & LazyLevelStore;
 
 type SlotRef = {
-    store: LevelStore;
+    store: LazyLevelStore;
     slot: number;
 };
 
@@ -25,35 +27,29 @@ type SlotRun = {
     length: number;
 };
 
-type LevelSync = {
-    store: LevelStore;
-    level: Level;
-};
-
 type ModelState = {
-    root: Gio.ListStore;
-    rootModels: GObject.Object[];
-    model: Gtk.FlattenListModel;
-    groupStores: LevelStore[];
+    root: CollectionRootStore | null;
+    model: Gtk.FlattenListModel | null;
+    groupStores: Map<number, LevelStore>;
     trees: Map<LevelStore, Gtk.TreeListModel>;
-    treeModels: Gtk.TreeListModel[];
     expansion: TreeExpansion;
     index: CollectionIndex;
 };
 
 type CollectionModel = {
-    model: Gtk.FlattenListModel;
     expansion: TreeExpansion;
     rowAt: (position: number) => Gtk.TreeListRow | null;
+    bind: (root: CollectionRootStore, model: Gtk.FlattenListModel) => void;
+    clear: () => void;
     sync: (index: CollectionIndex) => void;
 };
 
+type CollectionRootProps = { ref: Ref<CollectionRootStore> };
+
 const STORE_CLASS_KEY = Symbol.for("gtkx.components.lazy-level-store");
+const ROOT_CLASS_KEY = Symbol.for("gtkx.components.collection-root-store");
 const SLOTS_KEY = Symbol.for("gtkx.components.lazy-level-store.slots");
-const EMPTY_INDEX = createCollectionIndex(undefined, undefined, true);
-const SLOTS = sharedSlots();
-
-const newRootStore = (): Gio.ListStore => new Gio.ListStore({ itemType: GObject.TYPE_OBJECT });
+const EMPTY_INDEX = createCollectionIndex(undefined, [], true);
 
 function sharedSlots(): WeakMap<GObject.Object, SlotRef> {
     const cached: unknown = Reflect.get(globalThis, SLOTS_KEY);
@@ -81,6 +77,19 @@ function registeredStoreClass(): typeof LazyLevelStore {
     return LazyLevelStore;
 }
 
+function registeredRootClass(): unknown {
+    const cached: unknown = Reflect.get(globalThis, ROOT_CLASS_KEY);
+
+    if (typeof cached === "function") {
+        return cached;
+    }
+
+    registerClass(CollectionRootStore, { typeName: "GtkxCollectionRootStore", implements: [Gio.ListModel] });
+    Reflect.set(globalThis, ROOT_CLASS_KEY, CollectionRootStore);
+
+    return CollectionRootStore;
+}
+
 function slotRefFor(value: GObject.Object | null): SlotRef | null {
     const item = value instanceof Gtk.TreeListRow ? value.getItem() : value;
 
@@ -88,27 +97,18 @@ function slotRefFor(value: GObject.Object | null): SlotRef | null {
         return null;
     }
 
-    const ref = SLOTS.get(item);
+    const ref = sharedSlots().get(item);
 
     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 +116,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 +137,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 {
@@ -199,66 +203,32 @@ function emitFlips(store: LevelStore, flipped: Set<number>): void {
     }
 }
 
-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 undefined;
-    }
-
-    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[] = [];
-
-    for (let slot = 0; slot < overlap; slot++) {
-        const sync = childSync(context, store, slot, flipped);
-
-        if (sync !== undefined) {
-            syncs.push(sync);
-        }
-    }
-
-    return syncs;
-}
-
-function syncEntry(context: SyncContext, entry: LevelSync): LevelSync[] {
-    const { store, level } = entry;
-    const previousLength = store.refs.length;
+function syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
+    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 syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
-    const pending: LevelSync[] = [{ store, level }];
+    for (const [slot, child] of store.childStores) {
+        if (slot >= overlap || flipped.has(slot)) {
+            continue;
+        }
 
-    while (pending.length > 0) {
-        const entry = pending.pop();
+        const childLevel = context.index.childLevel(level, slot);
 
-        if (entry !== undefined) {
-            pending.push(...syncEntry(context, entry).toReversed());
+        if (childLevel !== undefined) {
+            syncLevel(context, child, childLevel);
         }
     }
 }
 
-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;
@@ -271,7 +241,7 @@ function ensureChildStore(index: CollectionIndex, store: LevelStore, slot: numbe
     }
 
     const created = newLevelStore(level);
-    store.childStores[slot] = created;
+    store.childStores.set(slot, created);
 
     return created;
 }
@@ -287,102 +257,81 @@ function childStoreFor(state: ModelState, object: GObject.Object): Gio.ListModel
 }
 
 function treeFor(state: ModelState, store: LevelStore): Gtk.TreeListModel {
-    return (
-        state.trees.get(store) ?? Gtk.TreeListModel.new(store, false, false, (object) => childStoreFor(state, object))
-    );
-}
+    const existing = state.trees.get(store);
 
-function nextTrees(state: ModelState, index: CollectionIndex): Map<LevelStore, Gtk.TreeListModel> {
-    if (!index.isTree) {
-        return new Map();
+    if (existing !== undefined) {
+        return existing;
     }
 
-    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);
-        }
-    }
-}
+    const created = Gtk.TreeListModel.new(store, false, false, (object) => childStoreFor(state, object));
+    state.trees.set(store, created);
 
-function adoptTrees(state: ModelState, index: CollectionIndex): void {
-    const next = nextTrees(state, index);
-    pruneRebuiltLevels(state, next);
-    state.trees = next;
-    state.treeModels = next.values().toArray();
+    return created;
 }
 
-function desiredRootModels(state: ModelState, index: CollectionIndex): GObject.Object[] {
-    adoptTrees(state, index);
+function rowAt(state: ModelState, position: number): Gtk.TreeListRow | null {
+    const item = state.model?.getItem(position);
 
-    return index.isTree ? [...state.treeModels] : [...state.groupStores];
+    return item instanceof Gtk.TreeListRow ? item : null;
 }
 
-function rowAt(state: ModelState, position: number): Gtk.TreeListRow | null {
-    let offset = position;
+function pruneGroups(state: ModelState, previous: CollectionIndex): void {
+    const hasModeChanged = previous.isTree !== state.index.isTree;
 
-    for (const tree of state.treeModels) {
-        const count = tree.getNItems();
+    for (const [group, store] of state.groupStores) {
+        const isRemoved = group >= state.index.groups.length;
 
-        if (offset < count) {
-            return tree.getRow(offset);
+        if (isRemoved || hasModeChanged) {
+            pruneSlots(state.expansion, store.level.path, () => true);
+            state.trees.delete(store);
         }
 
-        offset -= count;
+        if (isRemoved) {
+            state.groupStores.delete(group);
+        }
     }
-
-    return null;
 }
 
-function hasSameModels(previous: GObject.Object[], next: GObject.Object[]): boolean {
-    return previous.length === next.length && next.every((model, index) => previous[index] === model);
-}
+function syncRoot(state: ModelState, previous: CollectionIndex): void {
+    const before = previous.groups.length;
+    const after = state.index.groups.length;
 
-function syncRoot(state: ModelState, index: CollectionIndex): void {
-    const next = desiredRootModels(state, index);
+    if (previous.isTree !== state.index.isTree) {
+        state.root?.itemsChanged(0, before, after);
 
-    if (hasSameModels(state.rootModels, next)) {
         return;
     }
 
-    state.root.splice(0, state.rootModels.length, next);
-    state.rootModels = next;
-}
-
-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 groups.slice(state.groupStores.length)) {
-        state.groupStores.push(newLevelStore(level));
+    if (before !== after) {
+        const start = Math.min(before, after);
+        state.root?.itemsChanged(start, before - start, after - start);
     }
 }
 
-function stepGroupStores(state: ModelState, context: SyncContext, surviving: number): void {
-    for (const [group, level] of context.index.groups.entries()) {
-        const store = state.groupStores[group];
+function stepGroupStores(state: ModelState, context: SyncContext): void {
+    for (const [group, store] of state.groupStores) {
+        const level = context.index.groups[group];
 
-        if (store !== undefined && group < surviving) {
+        if (level !== undefined && store.level !== level) {
             syncLevel(context, store, level);
         }
     }
 }
 
 function syncModel(state: ModelState, index: CollectionIndex): void {
+    if (state.root === null) {
+        return;
+    }
+
     const context: SyncContext = { index, expansion: state.expansion };
-    const surviving = Math.min(state.groupStores.length, index.groups.length);
+    const previous = state.index;
     state.index = index;
     state.expansion.isSyncing = true;
 
     try {
-        adjustGroupStores(state, context);
-        syncRoot(state, index);
-        stepGroupStores(state, context, surviving);
+        pruneGroups(state, previous);
+        syncRoot(state, previous);
+        stepGroupStores(state, context);
     } finally {
         state.expansion.isSyncing = false;
     }
@@ -390,42 +339,104 @@ function syncModel(state: ModelState, index: CollectionIndex): void {
     adoptIndex(state.expansion, index);
 }
 
-function createCollectionModel(): CollectionModel {
-    registeredStoreClass();
-    const root = newRootStore();
+function clearModel(state: ModelState): void {
+    const root = state.root;
+    const previousLength = state.index.groups.length;
+    state.expansion.isSyncing = true;
+
+    try {
+        if (root !== null) {
+            root.state = null;
+        }
+
+        state.root = null;
+        state.model = null;
+        state.index = EMPTY_INDEX;
+        state.groupStores.clear();
+        state.trees.clear();
+        state.expansion.expanded.clear();
+        state.expansion.slots.clear();
+        adoptIndex(state.expansion, EMPTY_INDEX);
+
+        if (previousLength > 0) {
+            root?.itemsChanged(0, previousLength, 0);
+        }
+    } finally {
+        state.expansion.isSyncing = false;
+    }
+}
 
+function createCollectionModel(): CollectionModel {
     const state: ModelState = {
-        root,
-        rootModels: [],
-        model: Gtk.FlattenListModel.new(root),
-        groupStores: [],
+        root: null,
+        model: null,
+        groupStores: new Map(),
         trees: new Map(),
-        treeModels: [],
         expansion: createTreeExpansion(EMPTY_INDEX),
         index: EMPTY_INDEX,
     };
 
     return {
-        model: state.model,
         expansion: state.expansion,
         rowAt: (position) => rowAt(state, position),
+        bind: (root, model) => {
+            root.state = state;
+            state.root = root;
+            state.model = model;
+        },
+        clear: () => {
+            clearModel(state);
+        },
         sync: (index) => {
             syncModel(state, index);
         },
     };
 }
 
+class CollectionRootStore extends GObject.Object implements Gio.ListModelImpl {
+    declare itemsChanged: Gio.ListModel["itemsChanged"];
+    state: ModelState | null = null;
+
+    vfuncGetItemType(): bigint {
+        return GObject.TYPE_OBJECT;
+    }
+
+    vfuncGetNItems(): number {
+        return this.state?.index.groups.length ?? 0;
+    }
+
+    vfuncGetItem(position: number): GObject.Object | null {
+        const state = this.state;
+        const level = state?.index.groups[position];
+
+        if (state === null || level === undefined) {
+            return null;
+        }
+
+        let store = state.groupStores.get(position);
+
+        if (store === undefined) {
+            store = newLevelStore(level);
+            state.groupStores.set(position, store);
+        }
+
+        return state.index.isTree ? treeFor(state, store) : store;
+    }
+}
+
 class LazyLevelStore extends GObject.Object implements Gio.ListModelImpl {
     declare itemsChanged: Gio.ListModel["itemsChanged"];
     level: Level = { path: "", items: [], expandableFlags: [] };
-    refs: SlotRef[] = [];
-    objects: (Gtk.StringObject | null)[] = [];
-    childStores: (LevelStore | null)[] = [];
+    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;
-        SLOTS.set(created, ref);
+        this.refs.set(position, ref);
+        this.objects.set(position, created);
+        sharedSlots().set(created, ref);
 
         return created;
     }
@@ -435,18 +446,29 @@ 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);
     }
 }
 
-export { createCollectionModel, slotPathAt, slotRefFor, type CollectionModel, type SlotRef };
+const CollectionRoot: (props: CollectionRootProps) => ReactNode = createElementComponent<CollectionRootProps>(
+    "GtkxCollectionRootStore",
+    registeredRootClass(),
+);
+
+export {
+    CollectionRoot,
+    createCollectionModel,
+    slotPathAt,
+    slotRefFor,
+    type CollectionModel,
+    type CollectionRootStore,
+    type SlotRef,
+};

package/src/internal/collection.ts

@@ -1,14 +1,15 @@
+import type * as Gtk from "@gtkx/gi/gtk";
 import type { ListItem } from "../types.js";
-import type { CollectionIndex } from "./collection-index.js";
+import type { CollectionIndex, SectionIdentity } from "./collection-index.js";
 import type { CollectionModel, SlotRef } from "./collection-model.js";
 import type { MatchedRows } from "./tree-order.js";
 import { slotPathAt, slotRefFor } from "./collection-model.js";
 import { findIds, findRows } from "./tree-order.js";
 
-type Collection = Pick<CollectionModel, "model" | "expansion" | "rowAt"> & {
+type Collection = Pick<CollectionModel, "expansion" | "rowAt"> & {
     isTree: boolean;
     itemAt: (ref: SlotRef) => ListItem | undefined;
-    sectionFor: (levelPath: string) => unknown;
+    sectionFor: (levelPath: string) => SectionIdentity | undefined;
     idAt: (position: number) => string | null;
     idsAt: (positions: number[]) => string[];
     pathAt: (position: number) => string | null;
@@ -19,42 +20,42 @@ type Collection = Pick<CollectionModel, "model" | "expansion" | "rowAt"> & {
 const NO_ROWS: MatchedRows = { positions: [], ids: [] };
 const NO_IDS: string[] = [];
 
-function rowsFor(collectionModel: CollectionModel, ids: string[]): MatchedRows {
+function rowsFor(gtkModel: CollectionModel, ids: string[]): MatchedRows {
     if (ids.length === 0) {
         return NO_ROWS;
     }
 
-    const { expansion } = collectionModel;
+    const { expansion } = gtkModel;
 
     return findRows(expansion.index, expansion.slots, new Set(ids));
 }
 
-function positionFor(collectionModel: CollectionModel, id: string): number {
-    const [first = -1] = rowsFor(collectionModel, [id]).positions;
+function positionFor(gtkModel: CollectionModel, id: string): number {
+    const [first = -1] = rowsFor(gtkModel, [id]).positions;
 
     return first;
 }
 
-function refAt(collectionModel: CollectionModel, position: number): SlotRef | null {
+function refAt(model: Gtk.FlattenListModel | null, position: number): SlotRef | null {
     if (position < 0) {
         return null;
     }
 
-    return slotRefFor(collectionModel.model.getItem(position));
+    return slotRefFor(model?.getItem(position) ?? null);
 }
 
 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);
+function idAt(model: Gtk.FlattenListModel | null, index: CollectionIndex, position: number): string | null {
+    const ref = refAt(model, position);
 
     return ref === null ? null : (itemAt(index, ref)?.id ?? null);
 }
 
-function pathAt(collectionModel: CollectionModel, position: number): string | null {
-    const ref = refAt(collectionModel, position);
+function pathAt(model: Gtk.FlattenListModel | null, position: number): string | null {
+    const ref = refAt(model, position);
 
     if (ref === null) {
         return null;
@@ -63,12 +64,12 @@ function pathAt(collectionModel: CollectionModel, position: number): string | nu
     return slotPathAt(ref.store, ref.slot);
 }
 
-function idsAt(collectionModel: CollectionModel, positions: number[]): string[] {
+function idsAt(gtkModel: CollectionModel, positions: number[]): string[] {
     if (positions.length === 0) {
         return NO_IDS;
     }
 
-    const { expansion } = collectionModel;
+    const { expansion } = gtkModel;
 
     return findIds(expansion.index, expansion.slots, new Set(positions));
 }
@@ -79,19 +80,22 @@ function isCollectionIdle(collection: Collection): boolean {
     return !expansion.isApplying && !expansion.isSyncing;
 }
 
-function createCollection(collectionModel: CollectionModel, index: CollectionIndex): Collection {
+function createCollection(
+    gtkModel: CollectionModel,
+    index: CollectionIndex,
+    model: Gtk.FlattenListModel | null,
+): Collection {
     return {
-        model: collectionModel.model,
-        expansion: collectionModel.expansion,
+        expansion: gtkModel.expansion,
         isTree: index.isTree,
-        rowAt: collectionModel.rowAt,
+        rowAt: gtkModel.rowAt,
         itemAt: (ref) => itemAt(index, ref),
         sectionFor: index.sectionFor,
-        idAt: (position) => idAt(collectionModel, index, position),
-        idsAt: (positions) => idsAt(collectionModel, positions),
-        pathAt: (position) => pathAt(collectionModel, position),
-        positionFor: (id) => positionFor(collectionModel, id),
-        rowsFor: (ids) => rowsFor(collectionModel, ids),
+        idAt: (position) => idAt(model, index, position),
+        idsAt: (positions) => idsAt(gtkModel, positions),
+        pathAt: (position) => pathAt(model, position),
+        positionFor: (id) => positionFor(gtkModel, id),
+        rowsFor: (ids) => rowsFor(gtkModel, ids),
     };
 }