@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/level-bar.js

@@ -1,34 +1,23 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { filterProps, matchesAnyClass, shallowArrayEqual } from "./internal/utils.js";
+import { filterProps, shallowArrayEqual } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = ["offsets"];
-class LevelBarNode extends WidgetNode {
-    static priority = 1;
-    appliedOffsetIds = new Set();
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.LevelBar], containerOrClass);
+export class LevelBarNode extends WidgetNode {
+    appliedOffsets = [];
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(newProps);
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
-    }
-    applyOwnProps(oldProps, newProps) {
-        this.applyOffsets(oldProps, newProps);
-    }
-    applyOffsets(oldProps, newProps) {
+    applyOwnProps(newProps) {
         const newOffsets = newProps.offsets ?? [];
-        if (shallowArrayEqual(oldProps?.offsets ?? [], newOffsets)) {
+        if (shallowArrayEqual(this.appliedOffsets, newOffsets)) {
             return;
         }
-        for (const id of this.appliedOffsetIds) {
-            this.container.removeOffsetValue(id);
+        for (const offset of this.appliedOffsets) {
+            this.container.removeOffsetValue(offset.id);
         }
-        this.appliedOffsetIds.clear();
         for (const offset of newOffsets) {
             this.container.addOffsetValue(offset.id, offset.value);
-            this.appliedOffsetIds.add(offset.id);
         }
+        this.appliedOffsets = [...newOffsets];
     }
 }
-registerNodeClass(LevelBarNode);

package/dist/nodes/list-item.d.ts

@@ -1,15 +1,23 @@
 import type { ListItemProps } from "../jsx.js";
-import type { ListStore } from "./internal/list-store.js";
+import type { Node } from "../node.js";
+import { type TreeItemData } from "./internal/tree-store.js";
 import { VirtualNode } from "./virtual.js";
-type Props = Partial<ListItemProps>;
-export declare class ListItemNode<T extends {
+type ItemStore = {
     updateItem(id: string, value: unknown): void;
-} = ListStore, P extends Props = Props> extends VirtualNode<P> {
-    static priority: number;
+};
+export declare class ListItemNode extends VirtualNode<ListItemProps, Node, ListItemNode> {
     private store;
-    static matches(type: string): boolean;
-    setStore(store: T | null): void;
-    updateProps(oldProps: P | null, newProps: P): void;
-    protected applyOwnProps(oldProps: P | null, newProps: P): void;
+    private parentItemId;
+    static createItemData(props: ListItemProps): TreeItemData;
+    isValidChild(child: Node): boolean;
+    appendChild(child: ListItemNode): void;
+    insertBefore(child: ListItemNode, before: ListItemNode): void;
+    removeChild(child: ListItemNode): void;
+    commitUpdate(oldProps: ListItemProps | null, newProps: ListItemProps): void;
+    private applyOwnProps;
+    setStore(store: ItemStore | null): void;
+    getChildNodes(): readonly ListItemNode[];
+    setParentItemId(parentId: string | null): void;
+    getParentItemId(): string | null;
 }
 export {};

package/dist/nodes/list-item.js

@@ -1,27 +1,82 @@
-import { registerNodeClass } from "../registry.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
+import { TreeStore } from "./internal/tree-store.js";
 import { VirtualNode } from "./virtual.js";
 export class ListItemNode extends VirtualNode {
-    static priority = 1;
     store = null;
-    static matches(type) {
-        return type === "ListItem";
+    parentItemId = null;
+    static createItemData(props) {
+        return {
+            value: props.value,
+            indentForDepth: props.indentForDepth,
+            indentForIcon: props.indentForIcon,
+            hideExpander: props.hideExpander,
+        };
     }
-    setStore(store) {
-        this.store = store;
+    isValidChild(child) {
+        return child instanceof ListItemNode;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
+    appendChild(child) {
+        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);
+        }
+    }
+    insertBefore(child, before) {
+        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);
+        }
+    }
+    removeChild(child) {
+        if (this.store instanceof TreeStore) {
+            this.store.removeItem(child.props.id, this.props.id);
+        }
+        child.setStore(null);
+        child.setParentItemId(null);
+        super.removeChild(child);
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
         this.applyOwnProps(oldProps, newProps);
     }
     applyOwnProps(oldProps, newProps) {
         if (!this.store)
             return;
-        if (hasChanged(oldProps, newProps, "id") || hasChanged(oldProps, newProps, "value")) {
-            if (newProps.id !== undefined) {
+        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);
             }
         }
     }
+    setStore(store) {
+        this.store = store;
+        if (store === null || store instanceof TreeStore) {
+            for (const child of this.children) {
+                child.setStore(store);
+            }
+        }
+    }
+    getChildNodes() {
+        return this.children;
+    }
+    setParentItemId(parentId) {
+        this.parentItemId = parentId;
+    }
+    getParentItemId() {
+        return this.parentItemId;
+    }
 }
-registerNodeClass(ListItemNode);

package/dist/nodes/list-view.d.ts

@@ -1 +1,24 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkListViewProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import type { Container } from "../types.js";
+import { ListItemNode } from "./list-item.js";
+import { type ListModelProps } from "./models/list.js";
+import { WidgetNode } from "./widget.js";
+declare const RENDERER_PROPS: readonly ["renderItem", "estimatedItemHeight"];
+type ListViewProps = Pick<GtkListViewProps, (typeof RENDERER_PROPS)[number]> & ListModelProps;
+export declare class ListViewNode extends WidgetNode<Gtk.ListView, ListViewProps, ListItemNode> {
+    private itemRenderer;
+    private list;
+    isValidChild(child: Node): boolean;
+    constructor(typeName: string, props: ListViewProps, container: Gtk.ListView, rootContainer: Container);
+    appendChild(child: ListItemNode): void;
+    insertBefore(child: ListItemNode, before: ListItemNode): void;
+    removeChild(child: ListItemNode): void;
+    finalizeInitialChildren(props: ListViewProps): boolean;
+    commitUpdate(oldProps: ListViewProps | null, newProps: ListViewProps): void;
+    commitMount(): void;
+    detachDeletedInstance(): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/list-view.js

@@ -1,22 +1,20 @@
-import { isObjectEqual } from "@gtkx/ffi";
-import { LIST_WIDGET_CLASSES } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
 import { ListItemRenderer } from "./internal/list-item-renderer.js";
-import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { ListItemNode } from "./list-item.js";
 import { ListModel } from "./models/list.js";
 import { WidgetNode } from "./widget.js";
-const OWN_PROPS = ["renderItem", "estimatedItemHeight"];
-class ListViewNode extends WidgetNode {
-    static priority = 1;
+const RENDERER_PROPS = ["renderItem", "estimatedItemHeight"];
+const OWN_PROPS = [...RENDERER_PROPS, "autoexpand", "selectionMode", "selected", "onSelectionChanged"];
+export class ListViewNode extends WidgetNode {
     itemRenderer;
     list;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass(LIST_WIDGET_CLASSES, containerOrClass);
+    isValidChild(child) {
+        return child instanceof ListItemNode;
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
         this.list = new ListModel({ owner: this, signalStore: this.signalStore }, {
+            autoexpand: props.autoexpand,
             selectionMode: props.selectionMode,
             selected: props.selected,
             onSelectionChanged: props.onSelectionChanged,
@@ -26,36 +24,35 @@ class ListViewNode extends WidgetNode {
         this.list.getStore().setOnItemUpdated((id) => this.itemRenderer.rebindItem(id));
         this.container.setFactory(this.itemRenderer.getFactory());
     }
-    mount() {
-        super.mount();
-        this.container.setModel(this.list.getSelectionModel());
-    }
-    unmount() {
-        this.itemRenderer.dispose();
-        super.unmount();
-    }
     appendChild(child) {
-        if (!(child instanceof ListItemNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'ListView': expected x.ListItem`);
-        }
+        super.appendChild(child);
         this.list.appendChild(child);
     }
     insertBefore(child, before) {
-        if (!(child instanceof ListItemNode) || !(before instanceof ListItemNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' into 'ListView': expected x.ListItem`);
-        }
+        super.insertBefore(child, before);
         this.list.insertBefore(child, before);
     }
     removeChild(child) {
-        if (!(child instanceof ListItemNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'ListView': expected x.ListItem`);
-        }
         this.list.removeChild(child);
+        super.removeChild(child);
+    }
+    finalizeInitialChildren(props) {
+        super.finalizeInitialChildren(props);
+        return true;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.applyOwnProps(oldProps, newProps);
     }
+    commitMount() {
+        super.commitMount();
+        this.list.flushBatch();
+        this.container.setModel(this.list.getSelectionModel());
+    }
+    detachDeletedInstance() {
+        this.itemRenderer.dispose();
+        super.detachDeletedInstance();
+    }
     applyOwnProps(oldProps, newProps) {
         if (hasChanged(oldProps, newProps, "renderItem")) {
             this.itemRenderer.setRenderFn(newProps.renderItem ?? null);
@@ -64,11 +61,10 @@ class ListViewNode extends WidgetNode {
             this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight ?? null);
         }
         const previousModel = this.list.getSelectionModel();
-        this.list.updateProps(oldProps, newProps);
+        this.list.updateProps(oldProps ? filterProps(oldProps, RENDERER_PROPS) : null, filterProps(newProps, RENDERER_PROPS));
         const currentModel = this.list.getSelectionModel();
-        if (!isObjectEqual(previousModel, currentModel)) {
+        if (previousModel !== currentModel) {
             this.container.setModel(currentModel);
         }
     }
 }
-registerNodeClass(ListViewNode);

package/dist/nodes/menu.d.ts

@@ -1,8 +1,6 @@
 import type { Container } from "../types.js";
-import { MenuModel, type MenuProps } from "./models/menu.js";
+import { MenuModel, type MenuModelProps } from "./models/menu.js";
 export declare class MenuNode extends MenuModel {
-    static priority: number;
-    static matches(type: string): boolean;
     private static getType;
-    constructor(typeName: string, props: MenuProps, _container: undefined, rootContainer: Container);
+    constructor(typeName: string, props: MenuModelProps, _container: undefined, rootContainer: Container);
 }

package/dist/nodes/menu.js

@@ -1,11 +1,6 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
 import { MenuModel } from "./models/menu.js";
 export class MenuNode extends MenuModel {
-    static priority = 1;
-    static matches(type) {
-        return type === "MenuItem" || type === "MenuSection" || type === "MenuSubmenu";
-    }
     static getType(typeName) {
         if (typeName === "MenuItem") {
             return "item";
@@ -22,4 +17,3 @@ export class MenuNode extends MenuModel {
         super(MenuNode.getType(typeName), props, rootContainer, undefined, rootContainer instanceof Gtk.Application ? rootContainer : undefined);
     }
 }
-registerNodeClass(MenuNode);

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

@@ -0,0 +1,27 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkGridViewProps } from "../../jsx.js";
+import { ListStore } from "../internal/list-store.js";
+import type { SignalStore } from "../internal/signal-store.js";
+import type { ListItemNode } from "../list-item.js";
+export type GridModelProps = Pick<GtkGridViewProps, "selectionMode" | "selected" | "onSelectionChanged">;
+type GridModelConfig = {
+    owner: object;
+    signalStore: SignalStore;
+};
+export declare class GridModel {
+    private config;
+    private store;
+    private selectionManager;
+    private initialSelected;
+    constructor(config: GridModelConfig, props?: GridModelProps);
+    flushBatch(): void;
+    getStore(): ListStore;
+    getSelectionModel(): Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
+    appendChild(child: ListItemNode): void;
+    insertBefore(child: ListItemNode, before: ListItemNode): void;
+    removeChild(child: ListItemNode): void;
+    updateProps(oldProps: GridModelProps | null, newProps: GridModelProps): void;
+    private getSelection;
+    private resolveSelectionIndices;
+}
+export {};

package/dist/nodes/models/grid.js

@@ -0,0 +1,68 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { ListStore } from "../internal/list-store.js";
+import { SelectionModelController } from "../internal/selection-model-controller.js";
+export class GridModel {
+    config;
+    store;
+    selectionManager;
+    initialSelected;
+    constructor(config, props = {}) {
+        this.config = config;
+        this.store = new ListStore();
+        this.store.beginBatch();
+        this.initialSelected = props.selected;
+        this.selectionManager = new SelectionModelController({ ...config, ...props }, this.store.getModel(), () => this.getSelection(), (ids) => this.resolveSelectionIndices(ids), () => this.store.getModel().getNItems());
+    }
+    flushBatch() {
+        this.store.flushBatch();
+        this.selectionManager.reapplySelection(this.initialSelected);
+        this.initialSelected = undefined;
+    }
+    getStore() {
+        return this.store;
+    }
+    getSelectionModel() {
+        return this.selectionManager.getSelectionModel();
+    }
+    appendChild(child) {
+        child.setStore(this.store);
+        this.store.addItem(child.props.id, child.props.value);
+    }
+    insertBefore(child, before) {
+        child.setStore(this.store);
+        this.store.insertItemBefore(child.props.id, before.props.id, child.props.value);
+    }
+    removeChild(child) {
+        this.store.removeItem(child.props.id);
+        child.setStore(null);
+    }
+    updateProps(oldProps, newProps) {
+        this.selectionManager.update(oldProps ? { ...this.config, ...oldProps } : null, { ...this.config, ...newProps }, this.store.getModel());
+    }
+    getSelection() {
+        const model = this.store.getModel();
+        const selection = this.selectionManager.getSelectionModel().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;
+    }
+    resolveSelectionIndices(ids) {
+        const model = this.store.getModel();
+        const nItems = model.getNItems();
+        const selected = new Gtk.Bitset();
+        for (const id of ids) {
+            const index = model.find(id);
+            if (index < nItems) {
+                selected.add(index);
+            }
+        }
+        return selected;
+    }
+}

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

@@ -1,12 +1,9 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../../node.js";
-import { ListStore } from "../internal/list-store.js";
+import type { GtkListViewProps } from "../../jsx.js";
 import type { SignalStore } from "../internal/signal-store.js";
-export type ListProps = {
-    selectionMode?: Gtk.SelectionMode;
-    selected?: string[];
-    onSelectionChanged?: (ids: string[]) => void;
-};
+import { TreeStore } from "../internal/tree-store.js";
+import { ListItemNode } from "../list-item.js";
+export type ListModelProps = Pick<GtkListViewProps, "autoexpand" | "selectionMode" | "selected" | "onSelectionChanged">;
 type ListModelConfig = {
     owner: object;
     signalStore: SignalStore;
@@ -14,14 +11,19 @@ type ListModelConfig = {
 export declare class ListModel {
     private config;
     private store;
+    private treeListModel;
     private selectionManager;
-    constructor(config: ListModelConfig, props?: ListProps);
-    getStore(): ListStore;
+    private initialSelected;
+    constructor(config: ListModelConfig, props?: ListModelProps);
+    flushBatch(): void;
+    private createChildModel;
+    getStore(): TreeStore;
     getSelectionModel(): Gtk.NoSelection | 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;
+    appendChild(child: ListItemNode): void;
+    private addItemWithChildren;
+    insertBefore(child: ListItemNode, before: ListItemNode): void;
+    removeChild(child: ListItemNode): void;
+    updateProps(oldProps: ListModelProps | null, newProps: ListModelProps): void;
     private getSelection;
     private resolveSelectionIndices;
 }

package/dist/nodes/models/list.js

@@ -1,15 +1,31 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { ListStore } from "../internal/list-store.js";
-import { SelectionModelManager } from "../internal/selection-model.js";
+import { SelectionModelController } from "../internal/selection-model-controller.js";
+import { TreeStore } from "../internal/tree-store.js";
 import { ListItemNode } from "../list-item.js";
 export class ListModel {
     config;
     store;
+    treeListModel;
     selectionManager;
+    initialSelected;
     constructor(config, props = {}) {
         this.config = config;
-        this.store = new ListStore();
-        this.selectionManager = new SelectionModelManager({ ...config, ...props }, this.store.getModel(), () => this.getSelection(), (ids) => this.resolveSelectionIndices(ids), () => this.store.getModel().getNItems());
+        this.store = new TreeStore();
+        this.store.beginBatch();
+        this.initialSelected = props.selected;
+        this.treeListModel = new Gtk.TreeListModel(this.store.getRootModel(), false, props.autoexpand ?? false, (item) => this.createChildModel(item));
+        this.selectionManager = new SelectionModelController({ ...config, ...props }, this.treeListModel, () => this.getSelection(), (ids) => this.resolveSelectionIndices(ids), () => this.treeListModel.getNItems());
+    }
+    flushBatch() {
+        this.store.flushBatch();
+        this.selectionManager.reapplySelection(this.initialSelected);
+        this.initialSelected = undefined;
+    }
+    createChildModel(item) {
+        if (!(item instanceof Gtk.StringObject))
+            return null;
+        const parentId = item.getString();
+        return this.store.getChildrenModel(parentId);
     }
     getStore() {
         return this.store;
@@ -18,51 +34,57 @@ export class ListModel {
         return this.selectionManager.getSelectionModel();
     }
     appendChild(child) {
-        if (!(child instanceof ListItemNode)) {
-            return;
-        }
         child.setStore(this.store);
-        this.store.addItem(child.props.id, child.props.value);
+        this.addItemWithChildren(child);
     }
-    insertBefore(child, before) {
-        if (!(child instanceof ListItemNode) || !(before instanceof ListItemNode)) {
-            return;
+    addItemWithChildren(node, parentId) {
+        const id = node.props.id;
+        for (const child of node.getChildNodes()) {
+            this.addItemWithChildren(child, id);
         }
+        this.store.addItem(id, ListItemNode.createItemData(node.props), parentId);
+    }
+    insertBefore(child, before) {
         child.setStore(this.store);
-        this.store.insertItemBefore(child.props.id, before.props.id, child.props.value);
+        this.store.insertItemBefore(child.props.id, before.props.id, ListItemNode.createItemData(child.props));
     }
     removeChild(child) {
-        if (!(child instanceof ListItemNode)) {
-            return;
-        }
         this.store.removeItem(child.props.id);
         child.setStore(null);
     }
     updateProps(oldProps, newProps) {
-        this.selectionManager.update(oldProps ? { ...this.config, ...oldProps } : null, { ...this.config, ...newProps }, this.store.getModel());
+        if (!oldProps || oldProps.autoexpand !== newProps.autoexpand) {
+            this.treeListModel.setAutoexpand(newProps.autoexpand ?? false);
+        }
+        this.selectionManager.update(oldProps ? { ...this.config, ...oldProps } : null, { ...this.config, ...newProps }, this.treeListModel);
     }
     getSelection() {
-        const model = this.store.getModel();
         const selection = this.selectionManager.getSelectionModel().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);
+            const row = this.treeListModel.getRow(index);
+            if (!row)
+                continue;
+            const item = row.getItem();
+            if (item instanceof Gtk.StringObject) {
+                ids.push(item.getString());
             }
         }
         return ids;
     }
     resolveSelectionIndices(ids) {
-        const model = this.store.getModel();
-        const nItems = model.getNItems();
+        const nItems = this.treeListModel.getNItems();
         const selected = new Gtk.Bitset();
-        for (const id of ids) {
-            const index = model.find(id);
-            if (index < nItems) {
-                selected.add(index);
+        const idSet = new Set(ids);
+        for (let i = 0; i < nItems; i++) {
+            const row = this.treeListModel.getRow(i);
+            if (!row)
+                continue;
+            const item = row.getItem();
+            if (item instanceof Gtk.StringObject && idSet.has(item.getString())) {
+                selected.add(i);
             }
         }
         return selected;

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

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