@gtkx/react 0.6.1 → 0.7.0

package/dist/node.js

@@ -4,8 +4,10 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import * as GtkSource from "@gtkx/ffi/gtksource";
 import * as Vte from "@gtkx/ffi/vte";
 import * as WebKit from "@gtkx/ffi/webkit";
+import { isChildContainer } from "./container-interfaces.js";
 import { CONSTRUCTOR_PARAMS, PROP_SETTERS, SETTER_GETTERS } from "./generated/internal.js";
 import { isAddable, isAppendable, isRemovable, isSingleChild } from "./predicates.js";
+export const normalizeWidgetType = (type) => type.split(".")[0] || type;
 const NAMESPACE_REGISTRY = [
     ["GtkSource", GtkSource],
     ["WebKit", WebKit],
@@ -32,10 +34,12 @@ export class Node {
     static matches(_type, _existingWidget) {
         return false;
     }
+    static consumedPropNames = [];
     signalHandlers = new Map();
     widget = undefined;
     widgetType;
     nodeType;
+    parent = null;
     _state = null;
     get state() {
         if (this._state === null) {
@@ -51,7 +55,7 @@ export class Node {
     }
     constructor(type, existingWidget) {
         this.nodeType = type;
-        this.widgetType = type.split(".")[0] || type;
+        this.widgetType = normalizeWidgetType(type);
         if (existingWidget) {
             this.widget = existingWidget;
         }
@@ -67,12 +71,12 @@ export class Node {
         this.updateProps({}, props);
     }
     createWidget(type, props) {
-        const normalizedType = type.split(".")[0] || type;
-        const WidgetClass = resolveWidgetClass(normalizedType);
+        const widgetType = normalizeWidgetType(type);
+        const WidgetClass = resolveWidgetClass(widgetType);
         if (!WidgetClass) {
-            throw new Error(`Unknown GTK widget type: ${normalizedType}`);
+            throw new Error(`Unknown GTK widget type: ${widgetType}`);
         }
-        return new WidgetClass(...extractConstructorArgs(normalizedType, props));
+        return new WidgetClass(...extractConstructorArgs(widgetType, props));
     }
     getWidget() {
         return this.widget;
@@ -87,6 +91,13 @@ export class Node {
         child.attachToParentBefore(this, before);
     }
     attachToParent(parent) {
+        this.parent = parent;
+        if (isChildContainer(parent)) {
+            const widget = this.getWidget();
+            if (widget)
+                parent.attachChild(widget);
+            return;
+        }
         const parentWidget = parent.getWidget();
         const widget = this.getWidget();
         if (!parentWidget || !widget)
@@ -102,6 +113,14 @@ export class Node {
         }
     }
     detachFromParent(parent) {
+        this.parent = null;
+        this.disconnectAllSignals();
+        if (isChildContainer(parent)) {
+            const widget = this.getWidget();
+            if (widget)
+                parent.detachChild(widget);
+            return;
+        }
         const parentWidget = parent.getWidget();
         const widget = this.getWidget();
         if (!parentWidget || !widget)
@@ -113,7 +132,33 @@ export class Node {
             parentWidget.setChild(null);
         }
     }
+    disconnectAllSignals() {
+        const widget = this.getWidget();
+        if (!widget)
+            return;
+        for (const [_eventName, handlerId] of this.signalHandlers) {
+            GObject.signalHandlerDisconnect(widget, handlerId);
+        }
+        this.signalHandlers.clear();
+    }
+    hasParent() {
+        return this.parent !== null;
+    }
     attachToParentBefore(parent, before) {
+        this.parent = parent;
+        if (isChildContainer(parent)) {
+            const widget = this.getWidget();
+            const beforeWidget = before.getWidget();
+            if (widget) {
+                if (beforeWidget) {
+                    parent.insertChildBefore(widget, beforeWidget);
+                }
+                else {
+                    parent.attachChild(widget);
+                }
+            }
+            return;
+        }
         const parentWidget = parent.getWidget();
         const widget = this.getWidget();
         const beforeWidget = before.getWidget();
@@ -127,7 +172,18 @@ export class Node {
         }
     }
     consumedProps() {
-        return new Set(["children"]);
+        const consumed = new Set(["children"]);
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto.constructor !== Object) {
+            const propNames = proto.constructor.consumedPropNames;
+            if (propNames) {
+                for (const name of propNames) {
+                    consumed.add(name);
+                }
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return consumed;
     }
     updateProps(oldProps, newProps) {
         const widget = this.getWidget();

package/dist/nodes/action-bar.d.ts

@@ -1,9 +1,5 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer } from "../container-interfaces.js";
-import { Node } from "../node.js";
-export declare class ActionBarNode extends Node<Gtk.ActionBar> implements ChildContainer {
+import { PackContainerNode } from "./header-bar.js";
+export declare class ActionBarNode extends PackContainerNode<Gtk.ActionBar> {
     static matches(type: string): boolean;
-    attachChild(child: Gtk.Widget): void;
-    insertChildBefore(child: Gtk.Widget, _before: Gtk.Widget): void;
-    detachChild(child: Gtk.Widget): void;
 }

package/dist/nodes/action-bar.js

@@ -1,15 +1,6 @@
-import { Node } from "../node.js";
-export class ActionBarNode extends Node {
+import { PackContainerNode } from "./header-bar.js";
+export class ActionBarNode extends PackContainerNode {
     static matches(type) {
-        return type === "ActionBar";
-    }
-    attachChild(child) {
-        this.widget.packStart(child);
-    }
-    insertChildBefore(child, _before) {
-        this.attachChild(child);
-    }
-    detachChild(child) {
-        this.widget.remove(child);
+        return type === "ActionBar" || type === "ActionBar.Root";
     }
 }

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

@@ -1,62 +1,45 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type Reconciler from "react-reconciler";
-import { type ColumnContainer, type ItemContainer } from "../container-interfaces.js";
+import { type ColumnContainer } from "../container-interfaces.js";
 import type { Props } from "../factory.js";
 import { Node } from "../node.js";
-import type { ColumnSortFn, RenderItemFn } from "../types.js";
-interface ColumnViewState {
-    stringList: Gtk.StringList;
-    selectionModel: Gtk.SingleSelection;
-    sortListModel: Gtk.SortListModel;
-    items: unknown[];
+import type { RenderItemFn } from "../types.js";
+import { type ListItemFactoryHandlers, type ListItemInfo } from "./list-item-factory.js";
+import { SelectableListNode, type SelectableListState } from "./selectable-list.js";
+import { VirtualItemNode } from "./virtual-item.js";
+type ColumnViewState = SelectableListState & {
     columns: ColumnViewColumnNode[];
-    committedLength: number;
     sortColumn: string | null;
     sortOrder: Gtk.SortType;
-    sortFn: ColumnSortFn<unknown, string> | null;
-    isSorting: boolean;
     onSortChange: ((column: string | null, order: Gtk.SortType) => void) | null;
     sorterChangedHandlerId: number | null;
     lastNotifiedColumn: string | null;
     lastNotifiedOrder: Gtk.SortType;
-}
-export declare class ColumnViewNode extends Node<Gtk.ColumnView, ColumnViewState> implements ItemContainer<unknown>, ColumnContainer {
+};
+export declare class ColumnViewNode extends SelectableListNode<Gtk.ColumnView, ColumnViewState> implements ColumnContainer {
+    static consumedPropNames: string[];
     static matches(type: string): boolean;
     initialize(props: Props): void;
-    private initializeStateWithPlaceholders;
-    private createGtkModels;
     private connectSorterChangedSignal;
-    private waitForSortComplete;
     private disconnectSorterChangedSignal;
     private notifySortChange;
-    getItems(): unknown[];
-    getSortFn(): ColumnSortFn<unknown, string> | null;
-    compareItems(a: unknown, b: unknown, columnId: string): number;
+    detachFromParent(parent: Node): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+    private applySortIndicator;
     addColumn(columnNode: ColumnViewColumnNode): void;
-    private applySortByColumn;
-    findColumnById(id: string): ColumnViewColumnNode | undefined;
-    removeColumn(column: ColumnViewColumnNode): void;
     insertColumnBefore(column: ColumnViewColumnNode, before: ColumnViewColumnNode): void;
-    private syncStringList;
-    addItem(item: unknown): void;
-    insertItemBefore(item: unknown, beforeItem: unknown): void;
-    removeItem(item: unknown): void;
-    protected consumedProps(): Set<string>;
-    updateProps(oldProps: Props, newProps: Props): void;
-}
-interface ListItemInfo {
-    box: Gtk.Box;
-    fiberRoot: Reconciler.FiberRoot;
+    removeColumn(column: ColumnViewColumnNode): void;
 }
-interface ColumnViewColumnState {
+type ColumnViewColumnState = {
     column: Gtk.ColumnViewColumn;
     factory: Gtk.SignalListItemFactory;
+    factoryHandlers: ListItemFactoryHandlers | null;
     renderCell: RenderItemFn<unknown>;
     columnId: string | null;
     sorter: Gtk.CustomSorter | null;
     listItemCache: Map<number, ListItemInfo>;
-}
+};
 export declare class ColumnViewColumnNode extends Node<never, ColumnViewColumnState> {
+    static consumedPropNames: string[];
     static matches(type: string): boolean;
     protected isVirtual(): boolean;
     private columnView;
@@ -64,21 +47,13 @@ export declare class ColumnViewColumnNode extends Node<never, ColumnViewColumnSt
     getColumn(): Gtk.ColumnViewColumn;
     getId(): string | null;
     setColumnView(columnView: ColumnViewNode | null): void;
-    updateSorterFromRoot(): void;
+    updateSorter(): void;
     attachToParent(parent: Node): void;
     attachToParentBefore(parent: Node, before: Node): void;
     detachFromParent(parent: Node): void;
-    protected consumedProps(): Set<string>;
     updateProps(oldProps: Props, newProps: Props): void;
 }
-export declare class ColumnViewItemNode extends Node {
+export declare class ColumnViewItemNode extends VirtualItemNode {
     static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    private item;
-    initialize(props: Props): void;
-    getItem(): unknown;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    detachFromParent(parent: Node): void;
 }
 export {};