@gtkx/react 0.19.0 → 0.20.0

package/src/nodes/internal/header-renderer-manager.ts

@@ -1,33 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ReactNode } from "react";
-import { HeaderItemRenderer } from "./header-item-renderer.js";
-import type { SignalStore } from "./signal-store.js";
-
-type HeaderRendererConfig = {
-    signalStore: SignalStore;
-    isEnabled: () => boolean;
-    resolveItem: (id: string) => unknown;
-    setFactory: (factory: Gtk.SignalListItemFactory | null) => void;
-};
-
-export function updateHeaderRenderer(
-    current: HeaderItemRenderer | null,
-    config: HeaderRendererConfig,
-    renderFn: ((item: unknown) => ReactNode) | null | undefined,
-): HeaderItemRenderer | null {
-    if (renderFn) {
-        if (!current && config.isEnabled()) {
-            current = new HeaderItemRenderer(config.signalStore);
-            current.setResolveItem(config.resolveItem);
-            config.setFactory(current.getFactory());
-        }
-        if (current) {
-            current.setRenderFn(renderFn);
-        }
-    } else if (current) {
-        config.setFactory(null);
-        current.dispose();
-        current = null;
-    }
-    return current;
-}

package/src/nodes/internal/list-item-renderer.ts

@@ -1,162 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { ReactNode } from "react";
-import type Reconciler from "react-reconciler";
-import { reconciler } from "../../reconciler.js";
-import { BaseItemRenderer } from "./base-item-renderer.js";
-import type { TreeStore } from "./tree-store.js";
-
-type RenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
-
-type PendingBind = {
-    treeListRow: Gtk.TreeListRow;
-    expander: Gtk.TreeExpander;
-    id: string;
-};
-
-export class ListItemRenderer extends BaseItemRenderer<TreeStore> {
-    private expanders = new Map<Gtk.ListItem, Gtk.TreeExpander>();
-    private setupComplete = new Set<Gtk.ListItem>();
-    private pendingBinds = new Map<Gtk.ListItem, PendingBind>();
-    private renderFn: RenderItemFn<unknown> | null = () => null;
-    private boundItems = new Map<string, { listItem: Gtk.ListItem; treeListRow: Gtk.TreeListRow }>();
-
-    public setRenderFn(renderFn: RenderItemFn<unknown> | null): void {
-        this.renderFn = renderFn;
-        this.rebindAllItems();
-    }
-
-    public rebindAllItems(): void {
-        for (const id of this.boundItems.keys()) {
-            this.rebindItem(id);
-        }
-    }
-
-    public rebindItem(id: string): void {
-        const binding = this.boundItems.get(id);
-        if (!binding) return;
-
-        const fiberRoot = this.fiberRoots.get(binding.listItem);
-        if (!fiberRoot) return;
-
-        const expander = this.expanders.get(binding.listItem);
-        if (!expander) return;
-
-        this.renderBind(binding.listItem, expander, binding.treeListRow, id, fiberRoot);
-    }
-
-    public override dispose(): void {
-        super.dispose();
-        this.expanders.clear();
-        this.setupComplete.clear();
-        this.pendingBinds.clear();
-        this.boundItems.clear();
-    }
-
-    protected override renderItem(_listItem: Gtk.ListItem): ReactNode {
-        return this.renderFn?.(null, null);
-    }
-
-    protected override onSetup(listItem: Gtk.ListItem): Gtk.Widget {
-        const expander = new Gtk.TreeExpander();
-        const box = this.createBox();
-        expander.setChild(box);
-        listItem.setChild(expander);
-        this.expanders.set(listItem, expander);
-        return box;
-    }
-
-    protected override onSetupComplete(listItem: Gtk.ListItem): void {
-        this.setupComplete.add(listItem);
-        this.processPendingBind(listItem);
-    }
-
-    protected override onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void {
-        const expander = this.expanders.get(listItem);
-        if (!expander) return;
-
-        const treeListRow = listItem.getItem();
-        if (!(treeListRow instanceof Gtk.TreeListRow)) return;
-
-        expander.setListRow(treeListRow);
-
-        const stringObject = treeListRow.getItem();
-        if (!(stringObject instanceof Gtk.StringObject)) return;
-
-        const id = stringObject.getString();
-        this.boundItems.set(id, { listItem, treeListRow });
-
-        if (!this.setupComplete.has(listItem)) {
-            this.pendingBinds.set(listItem, { treeListRow, expander, id });
-            return;
-        }
-
-        this.renderBind(listItem, expander, treeListRow, id, fiberRoot);
-    }
-
-    protected override onUnbind(listItem: Gtk.ListItem): void {
-        const expander = listItem.getChild();
-        if (expander instanceof Gtk.TreeExpander) {
-            expander.setListRow(null);
-            const treeListRow = listItem.getItem();
-            if (treeListRow instanceof Gtk.TreeListRow) {
-                const stringObject = treeListRow.getItem();
-                if (stringObject instanceof Gtk.StringObject) {
-                    this.boundItems.delete(stringObject.getString());
-                }
-            }
-        }
-    }
-
-    protected override onTeardown(listItem: Gtk.ListItem): void {
-        this.expanders.delete(listItem);
-        this.setupComplete.delete(listItem);
-        this.pendingBinds.delete(listItem);
-    }
-
-    private processPendingBind(listItem: Gtk.ListItem): void {
-        const pending = this.pendingBinds.get(listItem);
-        if (!pending) return;
-
-        this.pendingBinds.delete(listItem);
-        const fiberRoot = this.fiberRoots.get(listItem);
-        if (fiberRoot) {
-            this.renderBind(listItem, pending.expander, pending.treeListRow, pending.id, fiberRoot);
-        }
-    }
-
-    private renderBind(
-        listItem: Gtk.ListItem,
-        expander: Gtk.TreeExpander,
-        treeListRow: Gtk.TreeListRow,
-        id: string,
-        fiberRoot: Reconciler.FiberRoot,
-    ): void {
-        const itemData = this.getStore().getItem(id);
-
-        if (itemData) {
-            expander.setIndentForDepth(itemData.indentForDepth ?? true);
-            expander.setHideExpander(itemData.hideExpander ?? false);
-
-            if (itemData.indentForIcon !== undefined) {
-                expander.setIndentForIcon(itemData.indentForIcon);
-            } else {
-                expander.setIndentForIcon(treeListRow.isExpandable());
-            }
-        } else {
-            expander.setIndentForIcon(treeListRow.isExpandable());
-        }
-
-        const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
-
-        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
-            if (this.tornDown.has(listItem)) return;
-            if (this.estimatedItemHeight !== null) return;
-            const currentExpander = this.expanders.get(listItem);
-            if (!currentExpander) return;
-            const box = currentExpander.getChild();
-            if (box) {
-                this.clearBoxSizeRequest(box);
-            }
-        });
-    }
-}

package/src/nodes/internal/list-store.ts

@@ -1,107 +0,0 @@
-import { SectionedListStore } from "./sectioned-list-store.js";
-
-type ItemUpdatedCallback = (id: string) => void;
-
-export class ListStore extends SectionedListStore {
-    private items = new Map<string, unknown>();
-    private onItemUpdated: ItemUpdatedCallback | null = null;
-
-    public setOnItemUpdated(callback: ItemUpdatedCallback | null): void {
-        this.onItemUpdated = callback;
-    }
-
-    protected override getInitialPendingBatch(): string[] | null {
-        return null;
-    }
-
-    protected override getModelString(itemId: string, _item: unknown): string {
-        return itemId;
-    }
-
-    protected override onItemAdded(itemId: string, item: unknown): void {
-        this.items.set(itemId, item);
-    }
-
-    protected override onItemRemoved(itemId: string): void {
-        this.items.delete(itemId);
-    }
-
-    public addItem(id: string, item: unknown): void {
-        this.flushRemovals();
-        this.items.set(id, item);
-
-        const existingIndex = this.idToIndex.get(id);
-        if (existingIndex !== undefined) {
-            this.model.remove(existingIndex);
-            this.ids.splice(existingIndex, 1);
-            this.rebuildIndices(existingIndex);
-        }
-
-        this.idToIndex.set(id, this.ids.length);
-        this.ids.push(id);
-
-        if (this.pendingBatch) {
-            this.pendingBatch.push(id);
-        } else {
-            this.model.append(id);
-        }
-    }
-
-    public insertItemBefore(id: string, beforeId: string, item: unknown): void {
-        this.flushRemovals();
-        this.items.set(id, item);
-
-        const existingIndex = this.idToIndex.get(id);
-        if (existingIndex !== undefined) {
-            this.model.remove(existingIndex);
-            this.ids.splice(existingIndex, 1);
-            this.idToIndex.delete(id);
-            this.rebuildIndices(existingIndex);
-        }
-
-        const beforeIndex = this.idToIndex.get(beforeId);
-        if (beforeIndex === undefined) {
-            this.idToIndex.set(id, this.ids.length);
-            this.ids.push(id);
-            this.model.append(id);
-        } else {
-            this.ids.splice(beforeIndex, 0, id);
-            this.rebuildIndices(beforeIndex);
-            this.model.splice(beforeIndex, 0, [id]);
-        }
-    }
-
-    public updateItem(id: string, item: unknown): void {
-        if (this.items.has(id)) {
-            this.items.set(id, item);
-            this.onItemUpdated?.(id);
-        } else {
-            this.addItem(id, item);
-        }
-    }
-
-    public getItem(id: string): unknown {
-        return this.items.get(id);
-    }
-
-    public getHeaderValue(itemId: string): unknown {
-        const sectionId = this.itemToSection.get(itemId);
-        if (sectionId) {
-            return this.headerValues.get(sectionId);
-        }
-        return undefined;
-    }
-
-    public getHeaderValueById(sectionId: string): unknown {
-        return this.headerValues.get(sectionId);
-    }
-
-    public getStringList(): import("@gtkx/ffi/gtk").StringList {
-        return this.model;
-    }
-
-    public getNItems(): number {
-        this.flushRemovals();
-        return this.ids.length;
-    }
-}

package/src/nodes/internal/sectioned-list-store.ts

@@ -1,287 +0,0 @@
-import * as Gio from "@gtkx/ffi/gio";
-import * as GObject from "@gtkx/ffi/gobject";
-import * as Gtk from "@gtkx/ffi/gtk";
-
-interface SectionData {
-    id: string;
-    model: Gtk.StringList;
-    itemIds: string[];
-    pendingBatch: string[] | null;
-}
-
-export abstract class SectionedListStore {
-    protected ids: string[] = [];
-    protected idToIndex = new Map<string, number>();
-    protected model = new Gtk.StringList();
-    protected pendingBatch: string[] | null = null;
-    private pendingRemovals: Set<string> | null = null;
-    private flushScheduled = false;
-
-    protected sectioned = false;
-    protected sections: SectionData[] = [];
-    protected sectionById = new Map<string, SectionData>();
-    protected itemToSection = new Map<string, string>();
-    protected headerValues = new Map<string, unknown>();
-    protected sectionContainer: Gio.ListStore | null = null;
-    protected flatModel: Gtk.FlattenListModel | null = null;
-
-    public enableSections(): void {
-        if (this.sectioned) return;
-        this.sectioned = true;
-        this.sectionContainer = new Gio.ListStore(GObject.typeFromName("GtkStringList"));
-        this.flatModel = new Gtk.FlattenListModel(this.sectionContainer);
-    }
-
-    public beginBatch(): void {
-        if (this.sectioned) {
-            for (const section of this.sections) {
-                section.pendingBatch = [];
-            }
-        } else {
-            this.pendingBatch = [];
-        }
-    }
-
-    public flushBatch(): void {
-        if (this.sectioned) {
-            for (const section of this.sections) {
-                const batch = section.pendingBatch;
-                section.pendingBatch = null;
-                if (batch && batch.length > 0) {
-                    section.model.splice(0, 0, batch);
-                }
-            }
-        } else {
-            const batch = this.pendingBatch;
-            this.pendingBatch = null;
-            if (batch && batch.length > 0) {
-                this.model.splice(0, 0, batch);
-            }
-        }
-    }
-
-    public addSection(id: string, value: unknown): void {
-        if (!this.sectioned) this.enableSections();
-
-        this.headerValues.set(id, value);
-        if (this.sectionById.has(id)) return;
-
-        const sectionModel = new Gtk.StringList();
-        const section: SectionData = {
-            id,
-            model: sectionModel,
-            itemIds: [],
-            pendingBatch: this.getInitialPendingBatch(),
-        };
-        this.sections.push(section);
-        this.sectionById.set(id, section);
-        this.sectionContainer?.append(sectionModel);
-    }
-
-    public removeSection(id: string): void {
-        const section = this.sectionById.get(id);
-        if (!section) return;
-
-        for (const itemId of [...section.itemIds]) {
-            this.removeItemFromSection(itemId);
-        }
-
-        const sectionIndex = this.sections.indexOf(section);
-        if (sectionIndex >= 0) {
-            this.sections.splice(sectionIndex, 1);
-            this.sectionContainer?.remove(sectionIndex);
-        }
-        this.sectionById.delete(id);
-        this.headerValues.delete(id);
-    }
-
-    public removeItemFromSection(itemId: string): void {
-        const sectionId = this.itemToSection.get(itemId);
-        if (!sectionId) return;
-
-        const section = this.sectionById.get(sectionId);
-        if (!section) return;
-
-        const indexInSection = section.itemIds.indexOf(itemId);
-        if (indexInSection >= 0) {
-            section.itemIds.splice(indexInSection, 1);
-            section.model.remove(indexInSection);
-        }
-
-        this.itemToSection.delete(itemId);
-        this.onItemRemoved(itemId);
-        this.rebuildGlobalIndices();
-    }
-
-    public removeItem(id: string): void {
-        if (this.sectioned) {
-            this.removeItemFromSection(id);
-            return;
-        }
-
-        if (!this.idToIndex.has(id)) return;
-
-        if (!this.pendingRemovals) {
-            this.pendingRemovals = new Set();
-            if (!this.flushScheduled) {
-                this.flushScheduled = true;
-                queueMicrotask(() => this.flushRemovals());
-            }
-        }
-        this.pendingRemovals.add(id);
-        this.onItemRemoved(id);
-    }
-
-    public flushRemovals(): void {
-        this.flushScheduled = false;
-        const removals = this.pendingRemovals;
-        if (!removals || removals.size === 0) {
-            this.pendingRemovals = null;
-            return;
-        }
-        this.pendingRemovals = null;
-
-        const indices: number[] = [];
-        for (const id of removals) {
-            const index = this.idToIndex.get(id);
-            if (index !== undefined) {
-                indices.push(index);
-                this.idToIndex.delete(id);
-            }
-        }
-
-        if (indices.length === 0) return;
-
-        indices.sort((a, b) => a - b);
-
-        let i = indices.length - 1;
-        while (i >= 0) {
-            let rangeStart = indices[i] ?? 0;
-            const rangeEnd = rangeStart;
-
-            while (i > 0) {
-                const prev = indices[i - 1];
-                if (prev !== rangeStart - 1) break;
-                i--;
-                rangeStart = prev ?? 0;
-            }
-
-            const count = rangeEnd - rangeStart + 1;
-            this.model.splice(rangeStart, count);
-            this.ids.splice(rangeStart, count);
-
-            i--;
-        }
-
-        this.rebuildIndices(0);
-    }
-
-    public addItemToSection(sectionId: string, itemId: string, item: unknown): void {
-        const section = this.sectionById.get(sectionId);
-        if (!section) return;
-
-        this.onItemAdded(itemId, item);
-        this.itemToSection.set(itemId, sectionId);
-        section.itemIds.push(itemId);
-        this.rebuildGlobalIndices();
-
-        const modelString = this.getModelString(itemId, item);
-        if (section.pendingBatch) {
-            section.pendingBatch.push(modelString);
-        } else {
-            section.model.append(modelString);
-        }
-    }
-
-    public addItemsToSection(sectionId: string, items: { itemId: string; item: unknown }[]): void {
-        const section = this.sectionById.get(sectionId);
-        if (!section) return;
-        if (items.length === 0) return;
-
-        const modelStrings: string[] = [];
-        for (const { itemId, item } of items) {
-            this.onItemAdded(itemId, item);
-            this.itemToSection.set(itemId, sectionId);
-            section.itemIds.push(itemId);
-            modelStrings.push(this.getModelString(itemId, item));
-        }
-
-        this.rebuildGlobalIndices();
-
-        if (section.pendingBatch) {
-            for (const s of modelStrings) {
-                section.pendingBatch.push(s);
-            }
-        } else {
-            section.model.splice(section.model.getNItems(), 0, modelStrings);
-        }
-    }
-
-    public insertItemToSectionBefore(sectionId: string, itemId: string, beforeId: string, item: unknown): void {
-        const section = this.sectionById.get(sectionId);
-        if (!section) return;
-
-        this.onItemAdded(itemId, item);
-        this.itemToSection.set(itemId, sectionId);
-
-        const modelString = this.getModelString(itemId, item);
-        const beforeIndex = section.itemIds.indexOf(beforeId);
-        if (beforeIndex >= 0) {
-            section.itemIds.splice(beforeIndex, 0, itemId);
-            this.rebuildGlobalIndices();
-            section.model.splice(beforeIndex, 0, [modelString]);
-        } else {
-            section.itemIds.push(itemId);
-            this.rebuildGlobalIndices();
-            section.model.append(modelString);
-        }
-    }
-
-    public updateHeaderValue(sectionId: string, value: unknown): void {
-        this.headerValues.set(sectionId, value);
-    }
-
-    public isSectioned(): boolean {
-        return this.sectioned;
-    }
-
-    public getModel(): Gio.ListModel {
-        if (this.sectioned && this.flatModel) return this.flatModel;
-        return this.model;
-    }
-
-    public getIdAtIndex(index: number): string | null {
-        this.flushRemovals();
-        return this.ids[index] ?? null;
-    }
-
-    public getIndexById(id: string): number | null {
-        this.flushRemovals();
-        return this.idToIndex.get(id) ?? null;
-    }
-
-    protected rebuildGlobalIndices(): void {
-        this.ids = [];
-        this.idToIndex.clear();
-        for (const section of this.sections) {
-            for (const itemId of section.itemIds) {
-                this.idToIndex.set(itemId, this.ids.length);
-                this.ids.push(itemId);
-            }
-        }
-    }
-
-    protected rebuildIndices(fromIndex: number): void {
-        for (let i = fromIndex; i < this.ids.length; i++) {
-            this.idToIndex.set(this.ids[i] as string, i);
-        }
-    }
-
-    protected abstract getInitialPendingBatch(): string[] | null;
-
-    protected abstract getModelString(itemId: string, item: unknown): string;
-
-    protected onItemAdded(_itemId: string, _item: unknown): void {}
-
-    protected onItemRemoved(_itemId: string): void {}
-}

package/src/nodes/internal/selection-helpers.ts

@@ -1,35 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-
-type StoreWithIdLookup = {
-    getIdAtIndex(index: number): string | null;
-};
-
-type StoreWithIndexLookup = {
-    getIndexById(id: string): number | null;
-    getNItems(): number;
-};
-
-export function getSelectionFromStore(selection: Gtk.Bitset, store: StoreWithIdLookup): string[] {
-    const size = selection.getSize();
-    const ids: string[] = [];
-    for (let i = 0; i < size; i++) {
-        const index = selection.getNth(i);
-        const id = store.getIdAtIndex(index);
-        if (id !== null) {
-            ids.push(id);
-        }
-    }
-    return ids;
-}
-
-export function resolveSelectionIndices(ids: string[], store: StoreWithIndexLookup): Gtk.Bitset {
-    const nItems = store.getNItems();
-    const selected = new Gtk.Bitset();
-    for (const id of ids) {
-        const index = store.getIndexById(id);
-        if (index !== null && index < nItems) {
-            selected.add(index);
-        }
-    }
-    return selected;
-}