@gtkx/react 0.14.0 → 0.16.0

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

@@ -1,6 +1,7 @@
 import * as Gio from "@gtkx/ffi/gio";
 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 = {
@@ -9,16 +10,16 @@ export type MenuProps = {
     accels?: string | string[];
     onActivate?: () => void;
 };
-export declare class Menu extends VirtualNode<MenuProps> {
-    private actionMap?;
+export declare class MenuModel extends VirtualNode<MenuProps> {
+    private actionMap;
     private actionPrefix;
-    private parent?;
+    private parent;
     private menu;
     private type;
-    private application?;
-    private action?;
+    private application;
+    private action;
     private children;
-    constructor(type: MenuType, props: MenuProps, actionMap?: Gio.ActionMap, application?: Gtk.Application);
+    constructor(type: MenuType, props: MenuProps, rootContainer: Container, actionMap?: Gio.ActionMap, application?: Gtk.Application);
     setActionMap(actionMap: Gio.ActionMap, prefix: string): void;
     private getAccels;
     private getActionName;
@@ -34,7 +35,7 @@ export declare class Menu extends VirtualNode<MenuProps> {
     getMenu(): Gio.Menu;
     private getAction;
     removeFromParent(): void;
-    insertInParentBefore(before: Menu): void;
+    insertInParentBefore(before: MenuModel): void;
     appendToParent(): void;
     appendChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;

package/dist/nodes/models/menu.js

@@ -1,23 +1,22 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import { isObjectEqual } from "@gtkx/ffi";
 import * as Gio from "@gtkx/ffi/gio";
 import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
-import { signalStore } from "../internal/signal-store.js";
 import { VirtualNode } from "../virtual.js";
-export class Menu extends VirtualNode {
-    actionMap;
+export class MenuModel extends VirtualNode {
+    actionMap = null;
     actionPrefix;
-    parent;
+    parent = null;
     menu;
     type;
-    application;
-    action;
+    application = null;
+    action = null;
     children = [];
-    constructor(type, props, actionMap, application) {
-        super("", props, undefined);
+    constructor(type, props, rootContainer, actionMap, application) {
+        super("", props, undefined, rootContainer);
         this.type = type;
-        this.actionMap = actionMap;
+        this.actionMap = actionMap ?? null;
         this.actionPrefix = application ? "app" : "menu";
-        this.application = application;
+        this.application = application ?? null;
         this.menu = new Gio.Menu();
     }
     setActionMap(actionMap, prefix) {
@@ -65,29 +64,25 @@ export class Menu extends VirtualNode {
         return this.actionMap;
     }
     createAction() {
-        batch(() => {
-            if (this.action) {
-                signalStore.set(this, this.action, "activate", undefined);
-            }
-            this.action = new Gio.SimpleAction(this.getId());
-            signalStore.set(this, this.action, "activate", this.getOnActivate());
-            this.getActionMap().addAction(this.action);
-            if (this.application && this.props.accels) {
-                this.application.setAccelsForAction(this.getActionName(), this.getAccels());
-            }
-        });
+        if (this.action) {
+            this.signalStore.set(this, this.action, "activate", null);
+        }
+        this.action = new Gio.SimpleAction(this.getId());
+        this.signalStore.set(this, this.action, "activate", this.getOnActivate());
+        this.getActionMap().addAction(this.action);
+        if (this.application && this.props.accels) {
+            this.application.setAccelsForAction(this.getActionName(), this.getAccels());
+        }
     }
     removeAction() {
-        batch(() => {
-            if (this.application && this.props.accels) {
-                this.application.setAccelsForAction(this.getActionName(), []);
-            }
-            if (this.action) {
-                this.getActionMap().removeAction(this.getId());
-                signalStore.set(this, this.action, "activate", undefined);
-                this.action = undefined;
-            }
-        });
+        if (this.application && this.props.accels) {
+            this.application.setAccelsForAction(this.getActionName(), []);
+        }
+        if (this.action) {
+            this.getActionMap().removeAction(this.getId());
+            this.signalStore.set(this, this.action, "activate", null);
+            this.action = null;
+        }
     }
     getPosition() {
         return this.findPositionIn(this.getParent());
@@ -125,7 +120,7 @@ export class Menu extends VirtualNode {
         if (!this.parent)
             return;
         const parent = this.parent;
-        this.parent = undefined;
+        this.parent = null;
         scheduleAfterCommit(() => {
             const position = this.findPositionIn(parent);
             if (position >= 0) {
@@ -152,7 +147,7 @@ export class Menu extends VirtualNode {
                     parent.insertSubmenu(beforePosition, this.menu, this.props.label);
                     break;
             }
-        });
+        }, CommitPriority.NORMAL);
     }
     appendToParent() {
         if (this.type === "item" && this.actionMap) {
@@ -171,10 +166,10 @@ export class Menu extends VirtualNode {
                     parent.appendSubmenu(this.menu, this.props.label);
                     break;
             }
-        });
+        }, CommitPriority.NORMAL);
     }
     appendChild(child) {
-        if (!(child instanceof Menu)) {
+        if (!(child instanceof MenuModel)) {
             return;
         }
         this.children.push(child);
@@ -185,7 +180,7 @@ export class Menu extends VirtualNode {
         child.appendToParent();
     }
     insertBefore(child, before) {
-        if (!(child instanceof Menu) || !(before instanceof Menu)) {
+        if (!(child instanceof MenuModel) || !(before instanceof MenuModel)) {
             return;
         }
         const beforeIndex = this.children.indexOf(before);
@@ -202,7 +197,7 @@ export class Menu extends VirtualNode {
         child.insertInParentBefore(before);
     }
     removeChild(child) {
-        if (!(child instanceof Menu)) {
+        if (!(child instanceof MenuModel)) {
             return;
         }
         const index = this.children.indexOf(child);
@@ -237,7 +232,7 @@ export class Menu extends VirtualNode {
             return;
         }
         if (oldProps.onActivate !== newProps.onActivate) {
-            signalStore.set(this, this.getAction(), "activate", newProps.onActivate);
+            this.signalStore.set(this, this.getAction(), "activate", newProps.onActivate);
         }
         if (oldProps.accels !== newProps.accels) {
             if (this.application) {
@@ -251,18 +246,16 @@ export class Menu extends VirtualNode {
         }
         if (!oldProps || oldProps.label !== newProps.label) {
             const parent = this.parent;
-            batch(() => {
-                const position = this.findPositionIn(parent);
-                if (position >= 0) {
-                    parent.remove(position);
-                    if (this.type === "section") {
-                        parent.insertSection(position, this.menu, this.props.label);
-                    }
-                    else if (this.type === "submenu") {
-                        parent.insertSubmenu(position, this.menu, this.props.label);
-                    }
+            const position = this.findPositionIn(parent);
+            if (position >= 0) {
+                parent.remove(position);
+                if (this.type === "section") {
+                    parent.insertSection(position, this.menu, this.props.label);
+                }
+                else if (this.type === "submenu") {
+                    parent.insertSubmenu(position, this.menu, this.props.label);
                 }
-            });
+            }
         }
     }
     unmount() {

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

@@ -1,5 +1,6 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Node } from "../../node.js";
+import type { Container } from "../../types.js";
 import { TreeStore } from "../internal/tree-store.js";
 import { VirtualNode } from "../virtual.js";
 export type TreeListProps = {
@@ -8,27 +9,20 @@ export type TreeListProps = {
     selected?: string[];
     onSelectionChanged?: (ids: string[]) => void;
 };
-type SelectionModel = Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
 export declare class TreeList extends VirtualNode<TreeListProps> {
     private store;
     private treeListModel;
-    private selectionModel;
-    private handleSelectionChange?;
-    private pendingSelection?;
-    private selectionScheduled;
-    constructor(props?: TreeListProps);
-    private initSelectionHandler;
+    private selectionManager;
+    constructor(props: TreeListProps | undefined, rootContainer: Container);
     private createChildModel;
     getStore(): TreeStore;
     getTreeListModel(): Gtk.TreeListModel;
-    getSelectionModel(): SelectionModel;
+    getSelectionModel(): Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
     appendChild(child: Node): void;
+    private addItemWithChildren;
     insertBefore(child: Node, before: Node): void;
     removeChild(child: Node): void;
     updateProps(oldProps: TreeListProps | null, newProps: TreeListProps): void;
-    private createSelectionModel;
     private getSelection;
-    private setSelection;
-    private applySelection;
+    private resolveSelectionIndices;
 }
-export {};

package/dist/nodes/models/tree-list.js

@@ -1,33 +1,17 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
-import { signalStore } from "../internal/signal-store.js";
+import { SelectionModelManager } from "../internal/selection-model.js";
 import { TreeStore } from "../internal/tree-store.js";
-import { TreeListItemNode } from "../tree-list-item.js";
+import { createTreeItemData, TreeListItemNode } from "../tree-list-item.js";
 import { VirtualNode } from "../virtual.js";
 export class TreeList extends VirtualNode {
     store;
     treeListModel;
-    selectionModel;
-    handleSelectionChange;
-    pendingSelection;
-    selectionScheduled = false;
-    constructor(props = {}) {
-        super("", {}, undefined);
+    selectionManager;
+    constructor(props = {}, rootContainer) {
+        super("", {}, undefined, rootContainer);
         this.store = new TreeStore();
         this.treeListModel = new Gtk.TreeListModel(this.store.getRootModel(), false, props.autoexpand ?? false, (item) => this.createChildModel(item));
-        this.selectionModel = this.createSelectionModel(props.selectionMode);
-        this.selectionModel.setModel(this.treeListModel);
-        this.initSelectionHandler(props.onSelectionChanged);
-    }
-    initSelectionHandler(onSelectionChanged) {
-        if (!onSelectionChanged) {
-            signalStore.set(this, this.selectionModel, "selection-changed", null);
-            return;
-        }
-        this.handleSelectionChange = () => {
-            onSelectionChanged(this.getSelection());
-        };
-        signalStore.set(this, this.selectionModel, "selection-changed", this.handleSelectionChange);
+        this.selectionManager = new SelectionModelManager({ owner: this, signalStore: this.signalStore, ...props }, this.treeListModel, () => this.getSelection(), (ids) => this.resolveSelectionIndices(ids), () => this.treeListModel.getNItems());
     }
     createChildModel(item) {
         if (!(item instanceof Gtk.StringObject))
@@ -42,7 +26,7 @@ export class TreeList extends VirtualNode {
         return this.treeListModel;
     }
     getSelectionModel() {
-        return this.selectionModel;
+        return this.selectionManager.getSelectionModel();
     }
     appendChild(child) {
         if (!(child instanceof TreeListItemNode)) {
@@ -51,16 +35,17 @@ export class TreeList extends VirtualNode {
         if (!child.props.id) {
             throw new Error("Cannot append 'TreeListItem' to 'TreeList': missing required 'id' prop");
         }
-        const id = child.props.id;
         child.setStore(this.store);
-        scheduleAfterCommit(() => {
-            this.store.addItem(id, {
-                value: child.props.value,
-                indentForDepth: child.props.indentForDepth,
-                indentForIcon: child.props.indentForIcon,
-                hideExpander: child.props.hideExpander,
-            });
-        });
+        this.addItemWithChildren(child);
+    }
+    addItemWithChildren(node, parentId) {
+        const id = node.props.id;
+        if (id === undefined)
+            return;
+        this.store.addItem(id, createTreeItemData(node.props), parentId);
+        for (const child of node.getChildNodes()) {
+            this.addItemWithChildren(child, id);
+        }
     }
     insertBefore(child, before) {
         if (!(child instanceof TreeListItemNode) || !(before instanceof TreeListItemNode)) {
@@ -75,14 +60,7 @@ export class TreeList extends VirtualNode {
         const id = child.props.id;
         const beforeId = before.props.id;
         child.setStore(this.store);
-        scheduleAfterCommit(() => {
-            this.store.insertItemBefore(id, beforeId, {
-                value: child.props.value,
-                indentForDepth: child.props.indentForDepth,
-                indentForIcon: child.props.indentForIcon,
-                hideExpander: child.props.hideExpander,
-            });
-        });
+        this.store.insertItemBefore(id, beforeId, createTreeItemData(child.props));
     }
     removeChild(child) {
         if (!(child instanceof TreeListItemNode)) {
@@ -92,9 +70,7 @@ export class TreeList extends VirtualNode {
             throw new Error("Cannot remove 'TreeListItem' from 'TreeList': missing required 'id' prop");
         }
         const id = child.props.id;
-        scheduleAfterCommit(() => {
-            this.store.removeItem(id);
-        });
+        this.store.removeItem(id);
         child.setStore(null);
     }
     updateProps(oldProps, newProps) {
@@ -102,36 +78,10 @@ export class TreeList extends VirtualNode {
         if (!oldProps || oldProps.autoexpand !== newProps.autoexpand) {
             this.treeListModel.setAutoexpand(newProps.autoexpand ?? false);
         }
-        if (oldProps && oldProps.selectionMode !== newProps.selectionMode) {
-            signalStore.set(this, this.selectionModel, "selection-changed", null);
-            this.selectionModel = this.createSelectionModel(newProps.selectionMode);
-            this.selectionModel.setModel(this.treeListModel);
-            this.initSelectionHandler(newProps.onSelectionChanged);
-            this.setSelection(newProps.selected);
-            return;
-        }
-        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
-            this.initSelectionHandler(newProps.onSelectionChanged);
-        }
-        if (!oldProps || oldProps.selected !== newProps.selected) {
-            this.setSelection(newProps.selected);
-        }
-    }
-    createSelectionModel(mode) {
-        const selectionMode = mode ?? Gtk.SelectionMode.SINGLE;
-        if (selectionMode === Gtk.SelectionMode.NONE) {
-            return new Gtk.NoSelection(this.treeListModel);
-        }
-        if (selectionMode === Gtk.SelectionMode.MULTIPLE) {
-            return new Gtk.MultiSelection(this.treeListModel);
-        }
-        const selectionModel = new Gtk.SingleSelection(this.treeListModel);
-        selectionModel.setAutoselect(selectionMode === Gtk.SelectionMode.BROWSE);
-        selectionModel.setCanUnselect(selectionMode !== Gtk.SelectionMode.BROWSE);
-        return selectionModel;
+        this.selectionManager.update(oldProps ? { owner: this, signalStore: this.signalStore, ...oldProps } : null, { owner: this, signalStore: this.signalStore, ...newProps }, this.treeListModel);
     }
     getSelection() {
-        const selection = this.selectionModel.getSelection();
+        const selection = this.selectionManager.getSelectionModel().getSelection();
         const size = selection.getSize();
         const ids = [];
         for (let i = 0; i < size; i++) {
@@ -146,31 +96,18 @@ export class TreeList extends VirtualNode {
         }
         return ids;
     }
-    setSelection(ids) {
-        this.pendingSelection = ids;
-        if (!this.selectionScheduled) {
-            this.selectionScheduled = true;
-            scheduleAfterCommit(() => this.applySelection(), CommitPriority.LOW);
-        }
-    }
-    applySelection() {
-        this.selectionScheduled = false;
-        const ids = this.pendingSelection;
-        this.pendingSelection = undefined;
+    resolveSelectionIndices(ids) {
         const nItems = this.treeListModel.getNItems();
         const selected = new Gtk.Bitset();
-        const mask = Gtk.Bitset.newRange(0, nItems);
-        if (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 && ids.includes(item.getString())) {
-                    selected.add(i);
-                }
+        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 && ids.includes(item.getString())) {
+                selected.add(i);
             }
         }
-        this.selectionModel.setSelection(selected, mask);
+        return selected;
     }
 }

package/dist/nodes/navigation-page.d.ts

@@ -6,6 +6,7 @@ export declare class NavigationPageNode extends SlotNode<Props> {
     static priority: number;
     static matches(type: string): boolean;
     updateProps(oldProps: Props | null, newProps: Props): void;
+    protected applyOwnProps(oldProps: Props | null, newProps: Props): void;
     protected onChildChange(oldChild: Adw.NavigationPage | null): void;
 }
 export {};

package/dist/nodes/navigation-page.js

@@ -1,5 +1,6 @@
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
+import { hasChanged } from "./internal/utils.js";
 import { SlotNode } from "./slot.js";
 export class NavigationPageNode extends SlotNode {
     static priority = 1;
@@ -8,17 +9,20 @@ export class NavigationPageNode extends SlotNode {
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
         const child = this.child;
         if (!(child instanceof Adw.NavigationPage)) {
             return;
         }
-        if (newProps.id !== undefined && (!oldProps || oldProps.id !== newProps.id)) {
+        if (hasChanged(oldProps, newProps, "id") && newProps.id !== undefined) {
             child.setTag(newProps.id);
         }
-        if (newProps.title !== undefined && (!oldProps || oldProps.title !== newProps.title)) {
+        if (hasChanged(oldProps, newProps, "title") && newProps.title !== undefined) {
             child.setTitle(newProps.title);
         }
-        if (newProps.canPop !== undefined && (!oldProps || oldProps.canPop !== newProps.canPop)) {
+        if (hasChanged(oldProps, newProps, "canPop") && newProps.canPop !== undefined) {
             child.setCanPop(newProps.canPop);
         }
     }

package/dist/nodes/navigation-view.js

@@ -1,16 +1,15 @@
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
-import { scheduleAfterCommit } from "../scheduler.js";
-import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { filterProps, hasChanged, matchesAnyClass, primitiveArrayEqual } from "./internal/utils.js";
 import { NavigationPageNode } from "./navigation-page.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
-const PROPS = ["history", "onHistoryChanged"];
+const OWN_PROPS = ["history", "onHistoryChanged"];
 class NavigationViewNode extends WidgetNode {
     static priority = 1;
     static matches(_type, containerOrClass) {
-        return isContainerType(Adw.NavigationView, containerOrClass);
+        return matchesAnyClass([Adw.NavigationView], containerOrClass);
     }
     appendChild(child) {
         if (child instanceof NavigationPageNode) {
@@ -45,35 +44,38 @@ class NavigationViewNode extends WidgetNode {
         throw new Error(`Cannot remove '${child.typeName}' from 'NavigationView': expected x.NavigationPage or Widget`);
     }
     updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
         const oldHistory = oldProps?.history;
         const newHistory = newProps.history;
-        if (newHistory && !this.arraysEqual(oldHistory, newHistory)) {
+        if (newHistory && !primitiveArrayEqual(oldHistory, newHistory)) {
             this.syncHistory(newHistory);
         }
-        if (!oldProps || oldProps.onHistoryChanged !== newProps.onHistoryChanged) {
+        if (hasChanged(oldProps, newProps, "onHistoryChanged")) {
             const onHistoryChanged = newProps.onHistoryChanged;
             if (onHistoryChanged) {
                 const handleHistoryChanged = () => {
                     const history = this.getCurrentHistory();
                     onHistoryChanged(history);
                 };
-                signalStore.set(this, this.container, "popped", handleHistoryChanged);
-                signalStore.set(this, this.container, "pushed", handleHistoryChanged);
-                signalStore.set(this, this.container, "replaced", handleHistoryChanged);
+                this.signalStore.set(this, this.container, "popped", handleHistoryChanged);
+                this.signalStore.set(this, this.container, "pushed", handleHistoryChanged);
+                this.signalStore.set(this, this.container, "replaced", handleHistoryChanged);
             }
             else {
-                signalStore.set(this, this.container, "popped", null);
-                signalStore.set(this, this.container, "pushed", null);
-                signalStore.set(this, this.container, "replaced", null);
+                this.signalStore.set(this, this.container, "popped", null);
+                this.signalStore.set(this, this.container, "pushed", null);
+                this.signalStore.set(this, this.container, "replaced", null);
             }
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
     }
     syncHistory(history) {
         const container = this.container;
         scheduleAfterCommit(() => {
             container.replaceWithTags(history, history.length);
-        });
+        }, CommitPriority.NORMAL);
     }
     getCurrentHistory() {
         const stack = this.container.getNavigationStack();
@@ -88,18 +90,5 @@ class NavigationViewNode extends WidgetNode {
         }
         return history;
     }
-    arraysEqual(a, b) {
-        if (a === b)
-            return true;
-        if (!a || !b)
-            return false;
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (a[i] !== b[i])
-                return false;
-        }
-        return true;
-    }
 }
 registerNodeClass(NavigationViewNode);

package/dist/nodes/notebook-page-tab.d.ts

@@ -4,10 +4,11 @@ import { SlotNode } from "./slot.js";
 type Props = Partial<SlotProps>;
 export declare class NotebookPageTabNode extends SlotNode<Props> {
     static priority: number;
-    private notebook?;
-    private page?;
+    private notebook;
+    private page;
     static matches(type: string): boolean;
-    setPage(notebook?: Gtk.Notebook, page?: Gtk.Widget): void;
+    setPage(notebook: Gtk.Notebook | null, page: Gtk.Widget | null): void;
+    updateProps(oldProps: Props | null, newProps: Props): void;
     private getNotebook;
     private getPage;
     protected onChildChange(_oldChild: Gtk.Widget | null): void;

package/dist/nodes/notebook-page-tab.js

@@ -2,8 +2,8 @@ import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 export class NotebookPageTabNode extends SlotNode {
     static priority = 1;
-    notebook;
-    page;
+    notebook = null;
+    page = null;
     static matches(type) {
         return type === "NotebookPageTab";
     }
@@ -12,6 +12,9 @@ export class NotebookPageTabNode extends SlotNode {
         this.page = page;
         this.setParent(notebook);
     }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+    }
     getNotebook() {
         if (!this.notebook) {
             throw new Error("Expected Notebook reference to be set on NotebookPageTabNode");

package/dist/nodes/notebook-page.d.ts

@@ -5,18 +5,20 @@ import { SlotNode } from "./slot.js";
 type Props = Partial<NotebookPageProps>;
 export declare class NotebookPageNode extends SlotNode<Props> {
     static priority: number;
-    position?: number | null;
-    private tabNode?;
+    position: number | null;
+    private tabNode;
     static matches(type: string): boolean;
-    setNotebook(notebook?: Gtk.Notebook): void;
-    setPosition(position?: number | null): void;
+    setParent(parent: Gtk.Widget | null): void;
+    setPosition(position: number | null): void;
     private getNotebook;
     private updateTabNode;
     appendChild(child: Node): void;
-    removeChild(child?: Node): void;
+    removeChild(child: Node): void;
     unmount(): void;
     updateProps(oldProps: Props | null, newProps: Props): void;
+    protected applyOwnProps(oldProps: Props | null, newProps: Props): void;
     private attachPage;
+    private applyPageProps;
     private detachPage;
     protected onChildChange(oldChild: Gtk.Widget | null): void;
 }