@gtkx/react 0.19.0 → 0.20.0

package/src/nodes/internal/selection-model-controller.ts

@@ -1,119 +0,0 @@
-import type * as Gio from "@gtkx/ffi/gio";
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { GtkListViewProps } from "../../jsx.js";
-import type { SignalStore } from "./signal-store.js";
-
-type SelectionModel = Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
-
-type SelectionModelConfig = Pick<GtkListViewProps, "selectionMode" | "selected" | "onSelectionChanged"> & {
-    owner: object;
-    signalStore: SignalStore;
-};
-
-export class SelectionModelController {
-    private owner: object;
-    private signalStore: SignalStore;
-    private selectionModel: SelectionModel;
-    private getSelection: () => string[];
-    private resolveSelectionIndices: (ids: string[]) => Gtk.Bitset;
-    private getItemCount: () => number;
-
-    constructor(
-        config: SelectionModelConfig,
-        model: Gio.ListModel,
-        getSelection: () => string[],
-        resolveSelectionIndices: (ids: string[]) => Gtk.Bitset,
-        getItemCount: () => number,
-    ) {
-        this.owner = config.owner;
-        this.signalStore = config.signalStore;
-        this.selectionModel = this.createSelectionModel(config.selectionMode, model);
-        this.selectionModel.setModel(model);
-        this.getSelection = getSelection;
-        this.resolveSelectionIndices = resolveSelectionIndices;
-        this.getItemCount = getItemCount;
-        this.initSelectionHandler(config.onSelectionChanged);
-        this.setSelection(config.selected);
-    }
-
-    public getSelectionModel(): SelectionModel {
-        return this.selectionModel;
-    }
-
-    public update(
-        oldProps: SelectionModelConfig | null,
-        newProps: SelectionModelConfig,
-        model: Gio.ListModel,
-    ): SelectionModel {
-        if (oldProps && oldProps.selectionMode !== newProps.selectionMode) {
-            this.signalStore.set(this.owner, this.selectionModel, "selection-changed", null);
-            this.selectionModel = this.createSelectionModel(newProps.selectionMode, model);
-            this.selectionModel.setModel(model);
-            this.initSelectionHandler(newProps.onSelectionChanged);
-            this.setSelection(newProps.selected);
-            return this.selectionModel;
-        }
-
-        if (this.selectionModel.getModel() !== model) {
-            this.selectionModel.setModel(model);
-        }
-
-        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
-            this.initSelectionHandler(newProps.onSelectionChanged);
-        }
-
-        if (!oldProps || oldProps.selected !== newProps.selected) {
-            this.setSelection(newProps.selected);
-        }
-
-        return this.selectionModel;
-    }
-
-    private initSelectionHandler(onSelectionChanged?: ((ids: string[]) => void) | null): void {
-        if (!onSelectionChanged) {
-            this.signalStore.set(this.owner, this.selectionModel, "selection-changed", null);
-            return;
-        }
-
-        const handler = () => {
-            onSelectionChanged(this.getSelection());
-        };
-
-        this.signalStore.set(this.owner, this.selectionModel, "selection-changed", handler);
-    }
-
-    private createSelectionModel(mode: Gtk.SelectionMode | null | undefined, model: Gio.ListModel): SelectionModel {
-        const selectionMode = mode ?? Gtk.SelectionMode.SINGLE;
-
-        if (selectionMode === Gtk.SelectionMode.NONE) {
-            return new Gtk.NoSelection(model);
-        }
-
-        if (selectionMode === Gtk.SelectionMode.MULTIPLE) {
-            return new Gtk.MultiSelection(model);
-        }
-
-        const selectionModel = new Gtk.SingleSelection(model);
-        selectionModel.setAutoselect(selectionMode === Gtk.SelectionMode.BROWSE);
-        selectionModel.setCanUnselect(selectionMode !== Gtk.SelectionMode.BROWSE);
-
-        return selectionModel;
-    }
-
-    public reapplySelection(ids?: string[] | null): void {
-        this.setSelection(ids);
-    }
-
-    private setSelection(ids?: string[] | null): void {
-        const nItems = this.getItemCount();
-        const selected = ids ? this.resolveSelectionIndices(ids) : new Gtk.Bitset();
-        const mask = Gtk.Bitset.newRange(0, nItems);
-
-        if (this.selectionModel instanceof Gtk.SingleSelection) {
-            const position = selected.getSize() > 0 ? selected.getNth(0) : Gtk.INVALID_LIST_POSITION;
-            this.selectionModel.setSelected(position);
-        } else {
-            this.selectionModel.setSelection(selected, mask);
-        }
-    }
-}

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

@@ -1,116 +0,0 @@
-import { SectionedListStore } from "./sectioned-list-store.js";
-
-export class SimpleListStore extends SectionedListStore {
-    private batchMode = false;
-
-    public override beginBatch(): void {
-        this.batchMode = true;
-        super.beginBatch();
-    }
-
-    public override flushBatch(): void {
-        this.batchMode = false;
-        super.flushBatch();
-    }
-
-    protected override getInitialPendingBatch(): string[] | null {
-        return this.batchMode ? [] : null;
-    }
-
-    protected override getModelString(_itemId: string, item: unknown): string {
-        return item as string;
-    }
-
-    public getHeaderValueByLabel(label: string): unknown {
-        for (const section of this.sections) {
-            if (section.model.getNItems() > 0) {
-                const firstLabel = section.model.getString(0);
-                if (firstLabel === label) {
-                    return this.headerValues.get(section.id);
-                }
-            }
-        }
-        return undefined;
-    }
-
-    public addItem(id: string, label: string): void {
-        this.flushRemovals();
-        if (this.sectioned) {
-            return;
-        }
-
-        this.idToIndex.set(id, this.ids.length);
-        this.ids.push(id);
-
-        if (this.pendingBatch) {
-            this.pendingBatch.push(label);
-        } else {
-            this.model.append(label);
-        }
-    }
-
-    public appendItem(id: string, label: string): void {
-        this.flushRemovals();
-        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);
-        this.model.append(label);
-    }
-
-    public insertItemBefore(id: string, beforeId: string, label: string): void {
-        this.flushRemovals();
-        const beforeIndex = this.idToIndex.get(beforeId);
-        if (beforeIndex === undefined) {
-            this.addItem(id, label);
-        } else {
-            this.ids.splice(beforeIndex, 0, id);
-            this.rebuildIndices(beforeIndex);
-            this.model.splice(beforeIndex, 0, [label]);
-        }
-    }
-
-    public updateItem(id: string, item: unknown): void {
-        this.flushRemovals();
-        const label = item as string;
-        if (this.sectioned) {
-            const sectionId = this.itemToSection.get(id);
-            if (!sectionId) return;
-            const section = this.sectionById.get(sectionId);
-            if (!section) return;
-            const indexInSection = section.itemIds.indexOf(id);
-            if (indexInSection >= 0) {
-                section.model.splice(indexInSection, 1, [label]);
-            }
-            return;
-        }
-        const index = this.idToIndex.get(id);
-        if (index === undefined) {
-            this.addItem(id, label);
-            return;
-        }
-        this.model.splice(index, 1, [label]);
-    }
-
-    public getItem(id: string): string | null {
-        this.flushRemovals();
-        if (this.sectioned) {
-            const sectionId = this.itemToSection.get(id);
-            if (!sectionId) return null;
-            const section = this.sectionById.get(sectionId);
-            if (!section) return null;
-            const indexInSection = section.itemIds.indexOf(id);
-            if (indexInSection < 0) return null;
-            return section.model.getString(indexInSection);
-        }
-        const index = this.idToIndex.get(id);
-        if (index === undefined) return null;
-        return this.model.getString(index);
-    }
-}

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

@@ -1,289 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-
-type TreeItemUpdatedCallback = (id: string) => void;
-
-export type TreeItemData<T = unknown> = {
-    value: T;
-    indentForDepth?: boolean;
-    indentForIcon?: boolean;
-    hideExpander?: boolean;
-};
-
-export class TreeStore {
-    private rootIds: string[] = [];
-    private rootIdToIndex = new Map<string, number>();
-    private children = new Map<string, string[]>();
-    private childIdToIndex = new Map<string, Map<string, number>>();
-    private rootModel = new Gtk.StringList();
-    private childModels = new Map<string, Gtk.StringList>();
-    private items = new Map<string, TreeItemData>();
-    private onItemUpdated: TreeItemUpdatedCallback | null = null;
-    private pendingBatch: string[] | null = null;
-    private pendingRemovals: Set<string> | null = null;
-    private flushScheduled = false;
-
-    public setOnItemUpdated(callback: TreeItemUpdatedCallback | null): void {
-        this.onItemUpdated = callback;
-    }
-
-    public beginBatch(): void {
-        this.pendingBatch = [];
-    }
-
-    public flushBatch(): void {
-        const batch = this.pendingBatch;
-        this.pendingBatch = null;
-        if (batch && batch.length > 0) {
-            this.rootModel.splice(0, 0, batch);
-        }
-    }
-
-    public updateItem(id: string, item: TreeItemData): void {
-        if (this.items.has(id)) {
-            this.items.set(id, item);
-            this.onItemUpdated?.(id);
-        } else {
-            this.addItem(id, item);
-        }
-    }
-
-    public addItem(id: string, data: TreeItemData, parentId?: string): void {
-        if (parentId === undefined) this.flushRemovals();
-        this.items.set(id, data);
-
-        if (parentId === undefined) {
-            const existingIndex = this.rootIdToIndex.get(id);
-            if (existingIndex !== undefined) {
-                this.rootModel.remove(existingIndex);
-                this.rootIds.splice(existingIndex, 1);
-                this.rebuildRootIndices(existingIndex);
-            }
-
-            this.rootIdToIndex.set(id, this.rootIds.length);
-            this.rootIds.push(id);
-
-            if (this.pendingBatch) {
-                this.pendingBatch.push(id);
-            } else {
-                this.rootModel.append(id);
-            }
-        } else {
-            let siblings = this.children.get(parentId);
-            let indexMap = this.childIdToIndex.get(parentId);
-            if (!siblings) {
-                siblings = [];
-                this.children.set(parentId, siblings);
-            }
-            if (!indexMap) {
-                indexMap = new Map();
-                this.childIdToIndex.set(parentId, indexMap);
-            }
-
-            const existingIndex = indexMap.get(id);
-            if (existingIndex !== undefined) {
-                const model = this.childModels.get(parentId);
-                if (model) {
-                    model.remove(existingIndex);
-                }
-                siblings.splice(existingIndex, 1);
-                this.rebuildChildIndices(siblings, indexMap, existingIndex);
-            }
-
-            indexMap.set(id, siblings.length);
-            siblings.push(id);
-
-            let model = this.childModels.get(parentId);
-            if (!model) {
-                model = new Gtk.StringList();
-                this.childModels.set(parentId, model);
-            }
-            model.append(id);
-        }
-    }
-
-    public removeItem(id: string, parentId?: string): void {
-        this.items.delete(id);
-        this.children.delete(id);
-        this.childIdToIndex.delete(id);
-        this.childModels.delete(id);
-
-        if (parentId !== undefined) {
-            const siblings = this.children.get(parentId);
-            const indexMap = this.childIdToIndex.get(parentId);
-            if (siblings && indexMap) {
-                const index = indexMap.get(id);
-                if (index !== undefined) {
-                    siblings.splice(index, 1);
-                    indexMap.delete(id);
-                    this.rebuildChildIndices(siblings, indexMap, index);
-                    const model = this.childModels.get(parentId);
-                    if (model) {
-                        model.remove(index);
-                    }
-                }
-                if (siblings.length === 0) {
-                    this.children.delete(parentId);
-                    this.childIdToIndex.delete(parentId);
-                }
-            }
-            return;
-        }
-
-        if (!this.rootIdToIndex.has(id)) return;
-
-        if (!this.pendingRemovals) {
-            this.pendingRemovals = new Set();
-            if (!this.flushScheduled) {
-                this.flushScheduled = true;
-                queueMicrotask(() => this.flushRemovals());
-            }
-        }
-        this.pendingRemovals.add(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.rootIdToIndex.get(id);
-            if (index !== undefined) {
-                indices.push(index);
-                this.rootIdToIndex.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.rootModel.splice(rangeStart, count);
-            this.rootIds.splice(rangeStart, count);
-
-            i--;
-        }
-
-        this.rebuildRootIndices(0);
-    }
-
-    public insertItemBefore(id: string, beforeId: string, data: TreeItemData, parentId?: string): void {
-        if (parentId === undefined) this.flushRemovals();
-        this.items.set(id, data);
-
-        if (parentId === undefined) {
-            const existingIndex = this.rootIdToIndex.get(id);
-            if (existingIndex !== undefined) {
-                this.rootModel.remove(existingIndex);
-                this.rootIds.splice(existingIndex, 1);
-                this.rootIdToIndex.delete(id);
-                this.rebuildRootIndices(existingIndex);
-            }
-
-            const beforeIndex = this.rootIdToIndex.get(beforeId);
-            if (beforeIndex === undefined) {
-                this.rootIdToIndex.set(id, this.rootIds.length);
-                this.rootIds.push(id);
-                this.rootModel.append(id);
-            } else {
-                this.rootIds.splice(beforeIndex, 0, id);
-                this.rebuildRootIndices(beforeIndex);
-                this.rootModel.splice(beforeIndex, 0, [id]);
-            }
-        } else {
-            let siblings = this.children.get(parentId);
-            let indexMap = this.childIdToIndex.get(parentId);
-            if (!siblings) {
-                siblings = [];
-                this.children.set(parentId, siblings);
-            }
-            if (!indexMap) {
-                indexMap = new Map();
-                this.childIdToIndex.set(parentId, indexMap);
-            }
-
-            let model = this.childModels.get(parentId);
-            if (!model) {
-                model = new Gtk.StringList();
-                this.childModels.set(parentId, model);
-            }
-
-            const existingIndex = indexMap.get(id);
-            if (existingIndex !== undefined) {
-                model.remove(existingIndex);
-                siblings.splice(existingIndex, 1);
-                indexMap.delete(id);
-                this.rebuildChildIndices(siblings, indexMap, existingIndex);
-            }
-
-            const beforeIndex = indexMap.get(beforeId);
-            if (beforeIndex === undefined) {
-                indexMap.set(id, siblings.length);
-                siblings.push(id);
-                model.append(id);
-            } else {
-                siblings.splice(beforeIndex, 0, id);
-                this.rebuildChildIndices(siblings, indexMap, beforeIndex);
-                model.splice(beforeIndex, 0, [id]);
-            }
-        }
-    }
-
-    public getItem(id: string): TreeItemData | undefined {
-        return this.items.get(id);
-    }
-
-    public getRootModel(): Gtk.StringList {
-        return this.rootModel;
-    }
-
-    public getChildrenModel(parentId: string): Gtk.StringList | null {
-        const childIds = this.children.get(parentId);
-        if (!childIds || childIds.length === 0) {
-            return null;
-        }
-
-        let model = this.childModels.get(parentId);
-        if (!model) {
-            model = new Gtk.StringList(childIds);
-            this.childModels.set(parentId, model);
-        }
-
-        return model;
-    }
-
-    public hasChildren(parentId: string): boolean {
-        const childIds = this.children.get(parentId);
-        return childIds !== undefined && childIds.length > 0;
-    }
-
-    private rebuildRootIndices(fromIndex: number): void {
-        for (let i = fromIndex; i < this.rootIds.length; i++) {
-            this.rootIdToIndex.set(this.rootIds[i] as string, i);
-        }
-    }
-
-    private rebuildChildIndices(siblings: string[], indexMap: Map<string, number>, fromIndex: number): void {
-        for (let i = fromIndex; i < siblings.length; i++) {
-            indexMap.set(siblings[i] as string, i);
-        }
-    }
-}

package/src/nodes/list-item.ts

@@ -1,107 +0,0 @@
-import type { ListItemProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import { hasChanged } from "./internal/props.js";
-import { type TreeItemData, TreeStore } from "./internal/tree-store.js";
-import { VirtualNode } from "./virtual.js";
-
-type ItemStore = { updateItem(id: string, value: unknown): void };
-
-export class ListItemNode extends VirtualNode<ListItemProps, Node, ListItemNode> {
-    private store: ItemStore | null = null;
-    private parentItemId: string | null = null;
-
-    public static createItemData(props: ListItemProps): TreeItemData {
-        return {
-            value: props.value,
-            indentForDepth: props.indentForDepth,
-            indentForIcon: props.indentForIcon,
-            hideExpander: props.hideExpander,
-        };
-    }
-
-    public override isValidChild(child: Node): boolean {
-        return child instanceof ListItemNode;
-    }
-
-    public override appendChild(child: ListItemNode): void {
-        super.appendChild(child);
-        child.setParentItemId(this.props.id);
-
-        if (this.store instanceof TreeStore) {
-            this.store.addItem(child.props.id, ListItemNode.createItemData(child.props), this.props.id);
-            child.setStore(this.store);
-        }
-    }
-
-    public override insertBefore(child: ListItemNode, before: ListItemNode): void {
-        super.insertBefore(child, before);
-        child.setParentItemId(this.props.id);
-
-        if (this.store instanceof TreeStore) {
-            this.store.insertItemBefore(
-                child.props.id,
-                before.props.id,
-                ListItemNode.createItemData(child.props),
-                this.props.id,
-            );
-            child.setStore(this.store);
-        }
-    }
-
-    public override removeChild(child: ListItemNode): void {
-        if (this.store instanceof TreeStore) {
-            this.store.removeItem(child.props.id, this.props.id);
-        }
-
-        child.setStore(null);
-        child.setParentItemId(null);
-        super.removeChild(child);
-    }
-
-    public override commitUpdate(oldProps: ListItemProps | null, newProps: ListItemProps): void {
-        super.commitUpdate(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
-    }
-
-    private applyOwnProps(oldProps: ListItemProps | null, newProps: ListItemProps): void {
-        if (!this.store) return;
-
-        if (this.store instanceof TreeStore) {
-            const propsChanged =
-                hasChanged(oldProps, newProps, "id") ||
-                hasChanged(oldProps, newProps, "value") ||
-                hasChanged(oldProps, newProps, "indentForDepth") ||
-                hasChanged(oldProps, newProps, "indentForIcon") ||
-                hasChanged(oldProps, newProps, "hideExpander");
-
-            if (propsChanged) {
-                this.store.updateItem(newProps.id, ListItemNode.createItemData(newProps));
-            }
-        } else {
-            if (hasChanged(oldProps, newProps, "id") || hasChanged(oldProps, newProps, "value")) {
-                this.store.updateItem(newProps.id, newProps.value);
-            }
-        }
-    }
-
-    public setStore(store: ItemStore | null): void {
-        this.store = store;
-        if (store === null || store instanceof TreeStore) {
-            for (const child of this.children) {
-                child.setStore(store);
-            }
-        }
-    }
-
-    public getChildNodes(): readonly ListItemNode[] {
-        return this.children;
-    }
-
-    public setParentItemId(parentId: string | null): void {
-        this.parentItemId = parentId;
-    }
-
-    public getParentItemId(): string | null {
-        return this.parentItemId;
-    }
-}

package/src/nodes/list-section.ts

@@ -1,64 +0,0 @@
-import type { ListSectionProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import { hasChanged } from "./internal/props.js";
-import { ListItemNode } from "./list-item.js";
-import { VirtualNode } from "./virtual.js";
-
-type SectionStore = {
-    addItemToSection(sectionId: string, itemId: string, item: unknown): void;
-    addItemsToSection(sectionId: string, items: { itemId: string; item: unknown }[]): void;
-    removeItemFromSection(itemId: string): void;
-    updateHeaderValue(sectionId: string, value: unknown): void;
-    insertItemToSectionBefore(sectionId: string, itemId: string, beforeId: string, item: unknown): void;
-    updateItem(id: string, item: unknown): void;
-};
-
-export class ListSectionNode extends VirtualNode<ListSectionProps, Node, ListItemNode> {
-    private store: SectionStore | null = null;
-
-    public override isValidChild(child: Node): boolean {
-        return child instanceof ListItemNode;
-    }
-
-    public override appendChild(child: ListItemNode): void {
-        super.appendChild(child);
-        if (this.store) {
-            this.store.addItemToSection(this.props.id, child.props.id, child.props.value);
-        }
-    }
-
-    public override insertBefore(child: ListItemNode, before: ListItemNode): void {
-        super.insertBefore(child, before);
-        if (this.store) {
-            this.store.insertItemToSectionBefore(this.props.id, child.props.id, before.props.id, child.props.value);
-        }
-    }
-
-    public override removeChild(child: ListItemNode): void {
-        if (this.store) {
-            this.store.removeItemFromSection(child.props.id);
-        }
-        super.removeChild(child);
-    }
-
-    public override commitUpdate(oldProps: ListSectionProps | null, newProps: ListSectionProps): void {
-        super.commitUpdate(oldProps, newProps);
-        if (this.store && hasChanged(oldProps, newProps, "value")) {
-            this.store.updateHeaderValue(newProps.id, newProps.value);
-        }
-    }
-
-    public setStore(store: SectionStore | null): void {
-        this.store = store;
-        if (store && this.children.length > 0) {
-            store.addItemsToSection(
-                this.props.id,
-                this.children.map((child) => ({ itemId: child.props.id, item: child.props.value })),
-            );
-        }
-    }
-
-    public getChildNodes(): readonly ListItemNode[] {
-        return this.children;
-    }
-}