@gtkx/react 0.9.3 → 0.10.0

package/dist/nodes/list-view.js

@@ -1,46 +1,53 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { connectListItemFactorySignals } from "./list-item-factory.js";
-import { SelectableListNode } from "./selectable-list.js";
-import { VirtualItemNode } from "./virtual-item.js";
-export class ListViewNode extends SelectableListNode {
-    static consumedPropNames = ["renderItem", "selected", "onSelectionChanged", "selectionMode"];
-    static matches(type) {
-        return type === "ListView.Root" || type === "GridView.Root";
+import { registerNodeClass } from "../registry.js";
+import { ListItemRenderer } from "./internal/list-item-renderer.js";
+import { filterProps, isContainerType } from "./internal/utils.js";
+import { ListItemNode } from "./list-item.js";
+import { List } from "./models/list.js";
+import { WidgetNode } from "./widget.js";
+const PROP_NAMES = ["renderItem"];
+class ListViewNode extends WidgetNode {
+    static priority = 1;
+    itemRenderer;
+    list;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.ListView, containerOrClass) || isContainerType(Gtk.GridView, containerOrClass);
     }
-    initialize(props) {
-        const selectionState = this.initializeSelectionState(props);
-        this.state = {
-            ...selectionState,
-            factory: new Gtk.SignalListItemFactory(),
-            factoryHandlers: null,
-            renderItem: props.renderItem,
-            listItemCache: new Map(),
-        };
-        super.initialize(props);
-        this.state.factoryHandlers = connectListItemFactorySignals({
-            factory: this.state.factory,
-            listItemCache: this.state.listItemCache,
-            getRenderFn: () => this.state.renderItem,
-            getItemAtPosition: (position) => this.getItems()[position] ?? null,
-        });
-        this.applySelectionModel();
-        this.widget.setFactory(this.state.factory);
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        this.list = new List();
+        this.itemRenderer = new ListItemRenderer(this.signalStore);
+        this.itemRenderer.setStore(this.list.getStore());
+        this.container.setFactory(this.itemRenderer.getFactory());
     }
-    unmount() {
-        this.state.factoryHandlers?.disconnect();
-        this.cleanupSelection();
-        super.unmount();
+    mount() {
+        super.mount();
+        this.container.setModel(this.list.getSelectionModel());
     }
-    updateProps(oldProps, newProps) {
-        if (oldProps.renderItem !== newProps.renderItem) {
-            this.state.renderItem = newProps.renderItem;
+    appendChild(child) {
+        if (!(child instanceof ListItemNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'ListView': expected ListItem`);
         }
-        this.updateSelectionProps(oldProps, newProps);
-        super.updateProps(oldProps, newProps);
+        this.list.appendChild(child);
     }
-}
-export class ListItemNode extends VirtualItemNode {
-    static matches(type) {
-        return type === "ListView.Item" || type === "GridView.Item";
+    insertBefore(child, before) {
+        if (!(child instanceof ListItemNode) || !(before instanceof ListItemNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' to 'ListView': expected ListItem`);
+        }
+        this.list.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (!(child instanceof ListItemNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'ListView': expected ListItem`);
+        }
+        this.list.removeChild(child);
+    }
+    updateProps(oldProps, newProps) {
+        if (!oldProps || oldProps.renderItem !== newProps.renderItem) {
+            this.itemRenderer.setRenderFn(newProps.renderItem);
+        }
+        this.list.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
     }
 }
+registerNodeClass(ListViewNode);

package/dist/nodes/menu.d.ts

@@ -1,108 +1,8 @@
-import * as Gio from "@gtkx/ffi/gio";
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-import { Node as NodeClass } from "../node.js";
-type MenuEntry = {
-    type: "item" | "section" | "submenu";
-    label?: string;
-    action?: string;
-    menu?: Gio.Menu;
-};
-interface MenuContainer {
-    getMenu(): Gio.Menu;
-    addMenuEntry(entry: MenuEntry): void;
-    removeMenuEntry(entry: MenuEntry): void;
-}
-interface MenuEntryNode {
-    parent: Node | null;
-    getMenuEntry(): MenuEntry;
-    setParentContainer(container: Node & MenuContainer): void;
-    onAttach(): void;
-    onDetach(): void;
-    unmount(): void;
-}
-declare abstract class MenuContainerNode<T extends Gtk.Widget | undefined> extends NodeClass<T> implements MenuContainer {
-    protected menu: Gio.Menu;
-    protected entries: MenuEntry[];
-    private rebuildScheduled;
-    getMenu(): Gio.Menu;
-    addMenuEntry(entry: MenuEntry): void;
-    removeMenuEntry(entry: MenuEntry): void;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    private scheduleRebuild;
-    protected rebuildMenu(): void;
-    protected onMenuRebuilt(): void;
-}
-type MenuWidget = Gtk.Widget & {
-    setMenuModel(model?: Gio.MenuModel): void;
-};
-declare abstract class MenuWidgetNode<T extends MenuWidget> extends MenuContainerNode<T> {
-    protected abstract createMenuWidget(menu: Gio.Menu): T;
-    initialize(props: Props): void;
-    protected onMenuRebuilt(): void;
-}
-export declare class PopoverMenuRootNode extends MenuWidgetNode<Gtk.PopoverMenu> {
-    static matches(type: string): boolean;
-    protected createMenuWidget(menu: Gio.Menu): Gtk.PopoverMenu;
-}
-export declare class PopoverMenuBarNode extends MenuWidgetNode<Gtk.PopoverMenuBar> {
-    static matches(type: string): boolean;
-    protected createMenuWidget(menu: Gio.Menu): Gtk.PopoverMenuBar;
-}
-export declare class ApplicationMenuNode extends MenuContainerNode<never> {
-    static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    mount(): void;
-    unmount(): void;
-    protected onMenuRebuilt(): void;
-}
-export declare class MenuItemNode extends NodeClass<never> implements MenuEntryNode {
-    static consumedPropNames: string[];
-    static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    private entry;
-    private action;
-    private actionName;
-    private signalHandlerId;
-    private onActivateCallback;
-    private currentAccels;
-    private parentContainer;
-    initialize(props: Props): void;
-    getMenuEntry(): MenuEntry;
-    setParentContainer(container: Node & MenuContainer): void;
-    onAttach(): void;
-    onDetach(): void;
-    unmount(): void;
-    private isFieldInitializationIncomplete;
-    updateProps(oldProps: Props, newProps: Props): void;
-    private invokeCurrentCallback;
-    private setupAction;
-    private cleanupAction;
-    private updateAccels;
-}
-declare class MenuContainerItemNode extends MenuContainerNode<never> implements MenuEntryNode {
-    static consumedPropNames: string[];
-    protected entryType: "section" | "submenu";
-    protected matchType: string;
-    static matches(_type: string): boolean;
-    protected isVirtual(): boolean;
-    private entry;
-    initialize(props: Props): void;
-    getMenuEntry(): MenuEntry;
-    setParentContainer(_container: Node & MenuContainer): void;
-    onAttach(): void;
-    onDetach(): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-}
-export declare class MenuSectionNode extends MenuContainerItemNode {
-    protected entryType: "section" | "submenu";
-    static matches(type: string): boolean;
-}
-export declare class MenuSubmenuNode extends MenuContainerItemNode {
-    protected entryType: "section" | "submenu";
+import type { Container } from "../types.js";
+import { Menu, type MenuProps } from "./models/menu.js";
+export declare class MenuNode extends Menu {
+    static priority: number;
     static matches(type: string): boolean;
+    private static getType;
+    constructor(typeName: string, props: MenuProps, _container: undefined, rootContainer?: Container);
 }
-export {};

package/dist/nodes/menu.js

@@ -1,277 +1,25 @@
-import { getApplication, getNativeObject } from "@gtkx/ffi";
-import * as Gio from "@gtkx/ffi/gio";
-import * as GObject from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { Node as NodeClass } from "../node.js";
-import { RootNode } from "./root.js";
-let actionCounter = 0;
-const generateActionName = () => `gtkx_menu_action_${actionCounter++}`;
-const isMenuEntryNode = (node) => "getMenuEntry" in node && "setParentContainer" in node;
-class MenuContainerNode extends NodeClass {
-    menu = new Gio.Menu();
-    entries = [];
-    rebuildScheduled = false;
-    getMenu() {
-        return this.menu;
-    }
-    addMenuEntry(entry) {
-        this.entries.push(entry);
-        this.scheduleRebuild();
-    }
-    removeMenuEntry(entry) {
-        const index = this.entries.indexOf(entry);
-        if (index !== -1) {
-            this.entries.splice(index, 1);
-            this.scheduleRebuild();
-        }
-    }
-    appendChild(child) {
-        if (isMenuEntryNode(child)) {
-            child.parent = this;
-            child.onAttach();
-            this.addMenuEntry(child.getMenuEntry());
-            child.setParentContainer(this);
-            return;
-        }
-        super.appendChild(child);
-    }
-    insertBefore(child, before) {
-        if (isMenuEntryNode(child)) {
-            child.parent = this;
-            child.onAttach();
-            this.addMenuEntry(child.getMenuEntry());
-            child.setParentContainer(this);
-            return;
-        }
-        super.insertBefore(child, before);
-    }
-    removeChild(child) {
-        if (isMenuEntryNode(child)) {
-            this.removeMenuEntry(child.getMenuEntry());
-            child.unmount();
-            child.parent = null;
-            return;
-        }
-        super.removeChild(child);
-    }
-    scheduleRebuild() {
-        if (this.rebuildScheduled)
-            return;
-        this.rebuildScheduled = true;
-        queueMicrotask(() => {
-            this.rebuildScheduled = false;
-            this.rebuildMenu();
-        });
-    }
-    rebuildMenu() {
-        this.menu.removeAll();
-        for (const entry of this.entries) {
-            if (entry.type === "item") {
-                this.menu.append(entry.label, entry.action);
-            }
-            else if (entry.type === "section" && entry.menu) {
-                this.menu.appendSection(entry.menu, entry.label);
-            }
-            else if (entry.type === "submenu" && entry.menu) {
-                this.menu.appendSubmenu(entry.menu, entry.label);
-            }
-        }
-        this.onMenuRebuilt();
-    }
-    onMenuRebuilt() { }
-}
-class MenuWidgetNode extends MenuContainerNode {
-    initialize(props) {
-        this.widget = this.createMenuWidget(this.menu);
-        super.initialize(props);
-    }
-    onMenuRebuilt() {
-        this.widget.setMenuModel(this.menu);
-    }
-}
-export class PopoverMenuRootNode extends MenuWidgetNode {
-    static matches(type) {
-        return type === "PopoverMenu.Root";
-    }
-    createMenuWidget(menu) {
-        return new Gtk.PopoverMenu(menu);
-    }
-}
-export class PopoverMenuBarNode extends MenuWidgetNode {
-    static matches(type) {
-        return type === "PopoverMenuBar";
-    }
-    createMenuWidget(menu) {
-        return new Gtk.PopoverMenuBar(menu);
-    }
-}
-export class ApplicationMenuNode extends MenuContainerNode {
-    static matches(type) {
-        return type === "ApplicationMenu";
-    }
-    isVirtual() {
-        return true;
-    }
-    mount() {
-        if (!(this.parent instanceof RootNode)) {
-            throw new Error("ApplicationMenu must be a direct child of a fragment at the root level");
-        }
-        getApplication().setMenubar(this.menu);
-    }
-    unmount() {
-        getApplication().setMenubar(undefined);
-        super.unmount();
-    }
-    onMenuRebuilt() {
-        getApplication().setMenubar(this.menu);
-    }
-}
-export class MenuItemNode extends NodeClass {
-    static consumedPropNames = ["label", "onActivate", "accels"];
+import { registerNodeClass } from "../registry.js";
+import { Menu } from "./models/menu.js";
+export class MenuNode extends Menu {
+    static priority = 1;
     static matches(type) {
-        return type === "Menu.Item";
-    }
-    isVirtual() {
-        return true;
-    }
-    entry = { type: "item" };
-    action = null;
-    actionName = null;
-    signalHandlerId = null;
-    onActivateCallback;
-    currentAccels;
-    parentContainer = null;
-    initialize(props) {
-        this.onActivateCallback = props.onActivate;
-        this.currentAccels = props.accels;
-        this.entry.label = props.label;
-        super.initialize(props);
-    }
-    getMenuEntry() {
-        return this.entry;
-    }
-    setParentContainer(container) {
-        this.parentContainer = container;
-    }
-    onAttach() {
-        this.setupAction();
-    }
-    onDetach() {
-        this.cleanupAction();
+        return type === "Menu.Item" || type === "Menu.Section" || type === "Menu.Submenu";
     }
-    unmount() {
-        this.cleanupAction();
-        this.parentContainer = null;
-        super.unmount();
-    }
-    isFieldInitializationIncomplete() {
-        return !this.entry;
-    }
-    updateProps(oldProps, newProps) {
-        if (this.isFieldInitializationIncomplete()) {
-            super.updateProps(oldProps, newProps);
-            return;
-        }
-        const labelChanged = oldProps.label !== newProps.label;
-        const callbackPresenceChanged = (oldProps.onActivate !== undefined) !== (newProps.onActivate !== undefined);
-        const accelsChanged = oldProps.accels !== newProps.accels;
-        this.onActivateCallback = newProps.onActivate;
-        this.currentAccels = newProps.accels;
-        if (labelChanged) {
-            this.entry.label = newProps.label;
-        }
-        if (this.parentContainer && callbackPresenceChanged) {
-            this.cleanupAction();
-            this.setupAction();
+    static getType(typeName) {
+        if (typeName === "Menu.Item") {
+            return "item";
         }
-        if (accelsChanged && this.actionName) {
-            this.updateAccels(this.currentAccels);
+        else if (typeName === "Menu.Section") {
+            return "section";
         }
-        super.updateProps(oldProps, newProps);
-    }
-    invokeCurrentCallback() {
-        this.onActivateCallback?.();
-    }
-    setupAction() {
-        if (!this.onActivateCallback)
-            return;
-        this.actionName = generateActionName();
-        this.action = new Gio.SimpleAction(this.actionName);
-        this.signalHandlerId = this.action.connect("activate", () => this.invokeCurrentCallback());
-        const app = getApplication();
-        const action = getNativeObject(this.action.id, Gio.Action);
-        if (!action) {
-            throw new Error("Failed to get Gio.Action interface from SimpleAction");
-        }
-        app.addAction(action);
-        this.entry.action = `app.${this.actionName}`;
-        if (this.currentAccels) {
-            this.updateAccels(this.currentAccels);
+        else if (typeName === "Menu.Submenu") {
+            return "submenu";
         }
+        throw new Error(`Unable to find menu type '${typeName}'`);
     }
-    cleanupAction() {
-        if (this.actionName) {
-            const app = getApplication();
-            app.removeAction(this.actionName);
-            if (this.currentAccels) {
-                app.setAccelsForAction(`app.${this.actionName}`, []);
-            }
-        }
-        if (this.action && this.signalHandlerId !== null) {
-            GObject.signalHandlerDisconnect(this.action, this.signalHandlerId);
-        }
-        this.action = null;
-        this.actionName = null;
-        this.signalHandlerId = null;
-        this.entry.action = undefined;
-    }
-    updateAccels(accels) {
-        if (!this.actionName)
-            return;
-        const app = getApplication();
-        const accelArray = accels ? (Array.isArray(accels) ? accels : [accels]) : [];
-        app.setAccelsForAction(`app.${this.actionName}`, accelArray);
-    }
-}
-class MenuContainerItemNode extends MenuContainerNode {
-    static consumedPropNames = ["label"];
-    entryType = "section";
-    matchType = "";
-    static matches(_type) {
-        return false;
-    }
-    isVirtual() {
-        return true;
-    }
-    entry = { type: "section" };
-    initialize(props) {
-        this.entry = { type: this.entryType };
-        this.entry.menu = this.menu;
-        this.entry.label = props.label;
-        super.initialize(props);
-    }
-    getMenuEntry() {
-        return this.entry;
-    }
-    setParentContainer(_container) { }
-    onAttach() { }
-    onDetach() { }
-    updateProps(oldProps, newProps) {
-        if (oldProps.label !== newProps.label && this.entry) {
-            this.entry.label = newProps.label;
-        }
-        super.updateProps(oldProps, newProps);
-    }
-}
-export class MenuSectionNode extends MenuContainerItemNode {
-    entryType = "section";
-    static matches(type) {
-        return type === "Menu.Section";
-    }
-}
-export class MenuSubmenuNode extends MenuContainerItemNode {
-    entryType = "submenu";
-    static matches(type) {
-        return type === "Menu.Submenu";
+    constructor(typeName, props, _container, rootContainer) {
+        super(MenuNode.getType(typeName), props, undefined, rootContainer instanceof Gtk.Application ? rootContainer : undefined);
     }
 }
+registerNodeClass(MenuNode);

package/dist/nodes/models/list.d.ts

@@ -0,0 +1,24 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import { ListStore } from "../internal/list-store.js";
+import { VirtualNode } from "../virtual.js";
+export type ListProps = {
+    selectionMode?: Gtk.SelectionMode;
+    selected?: string[];
+    onSelectionChanged?: (ids: string[]) => void;
+};
+export declare class List extends VirtualNode<ListProps> {
+    private store;
+    private selectionModel;
+    private handleSelectionChange?;
+    constructor(selectionMode?: Gtk.SelectionMode);
+    getStore(): ListStore;
+    getSelectionModel(): Gtk.SingleSelection | Gtk.MultiSelection;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
+    updateProps(oldProps: ListProps | null, newProps: ListProps): void;
+    private createSelectionModel;
+    private getSelection;
+    private setSelection;
+}

package/dist/nodes/models/list.js

@@ -0,0 +1,102 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { ListStore } from "../internal/list-store.js";
+import { ListItemNode } from "../list-item.js";
+import { VirtualNode } from "../virtual.js";
+export class List extends VirtualNode {
+    store;
+    selectionModel;
+    handleSelectionChange;
+    constructor(selectionMode) {
+        super("", {}, undefined);
+        this.store = new ListStore();
+        this.selectionModel = this.createSelectionModel(selectionMode);
+        this.selectionModel.setModel(this.store.getModel());
+    }
+    getStore() {
+        return this.store;
+    }
+    getSelectionModel() {
+        return this.selectionModel;
+    }
+    appendChild(child) {
+        if (!(child instanceof ListItemNode)) {
+            return;
+        }
+        child.setStore(this.store);
+        this.store.addItem(child.props.id, child.props.value);
+    }
+    insertBefore(child, before) {
+        if (!(child instanceof ListItemNode) || !(before instanceof ListItemNode)) {
+            return;
+        }
+        child.setStore(this.store);
+        this.store.insertItemBefore(child.props.id, before.props.id, child.props.value);
+    }
+    removeChild(child) {
+        if (!(child instanceof ListItemNode)) {
+            return;
+        }
+        this.store.removeItem(child.props.id);
+        child.setStore(undefined);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!oldProps || oldProps.selectionMode !== newProps.selectionMode) {
+            this.signalStore.set(this.selectionModel, "selection-changed", undefined);
+            this.selectionModel = this.createSelectionModel(newProps.selectionMode);
+        }
+        if (!oldProps ||
+            oldProps.onSelectionChanged !== newProps.onSelectionChanged ||
+            oldProps.selectionMode !== newProps.selectionMode) {
+            const onSelectionChanged = newProps.onSelectionChanged;
+            this.handleSelectionChange = () => {
+                onSelectionChanged?.(this.getSelection());
+            };
+            this.signalStore.set(this.selectionModel, "selection-changed", newProps.onSelectionChanged ? this.handleSelectionChange : undefined);
+        }
+        if (!oldProps || oldProps.selected !== newProps.selected || oldProps.selectionMode !== newProps.selectionMode) {
+            this.setSelection(newProps.selected);
+        }
+    }
+    createSelectionModel(mode) {
+        const model = this.store.getModel();
+        const selectionMode = mode ?? Gtk.SelectionMode.SINGLE;
+        const selectionModel = selectionMode === Gtk.SelectionMode.MULTIPLE
+            ? new Gtk.MultiSelection(model)
+            : new Gtk.SingleSelection(model);
+        if (selectionModel instanceof Gtk.SingleSelection) {
+            selectionModel.setAutoselect(false);
+            selectionModel.setCanUnselect(true);
+        }
+        return selectionModel;
+    }
+    getSelection() {
+        const model = this.store.getModel();
+        const selection = this.selectionModel.getSelection();
+        const size = selection.getSize();
+        const ids = [];
+        for (let i = 0; i < size; i++) {
+            const index = selection.getNth(i);
+            const id = model.getString(index);
+            if (id !== null) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    }
+    setSelection(ids) {
+        const model = this.store.getModel();
+        const nItems = model.getNItems();
+        const selected = new Gtk.Bitset();
+        const mask = Gtk.Bitset.newRange(0, nItems);
+        if (ids) {
+            for (const id of ids) {
+                const index = model.find(id);
+                if (index < nItems) {
+                    selected.add(index);
+                }
+            }
+        }
+        this.selectionModel.setSelection(selected, mask);
+    }
+}

package/dist/nodes/models/menu.d.ts

@@ -0,0 +1,45 @@
+import * as Gio from "@gtkx/ffi/gio";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import { VirtualNode } from "../virtual.js";
+export type MenuType = "root" | "item" | "section" | "submenu";
+export type MenuProps = {
+    id?: string;
+    label?: string;
+    accels?: string | string[];
+    onActivate?: () => void;
+};
+export declare class Menu extends VirtualNode<MenuProps> {
+    private actionMap?;
+    private actionPrefix;
+    private parent?;
+    private menu;
+    private type;
+    private application?;
+    private action?;
+    private children;
+    constructor(type: MenuType, props: MenuProps, actionMap?: Gio.ActionMap, application?: Gtk.Application);
+    setActionMap(actionMap: Gio.ActionMap, prefix: string): void;
+    private getAccels;
+    private getActionName;
+    private getOnActivate;
+    private getId;
+    private getParent;
+    private getActionMap;
+    createAction(): void;
+    private removeAction;
+    private getPosition;
+    private setParent;
+    getMenu(): Gio.Menu;
+    private getAction;
+    removeFromParent(): void;
+    insertInParentBefore(before: Menu): void;
+    appendToParent(): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
+    updateProps(oldProps: MenuProps | null, newProps: MenuProps): void;
+    private updateItemProps;
+    private updateContainerProps;
+    unmount(): void;
+}