@gtkx/react 0.1.11 → 0.1.14

package/dist/index.js

@@ -3,12 +3,11 @@ export * from "./generated/jsx.js";
 export { createPortal } from "./portal.js";
 export { render } from "./render.js";
 import { stop } from "@gtkx/ffi";
-import { disposeAllInstances, reconciler } from "./reconciler.js";
+import { reconciler } from "./reconciler.js";
 import { container } from "./render.js";
 export const quit = () => {
     reconciler.updateContainer(null, container, null, () => {
-        disposeAllInstances();
         stop();
     });
-    return false;
+    return true;
 };

package/dist/node.d.ts

@@ -1,13 +1,23 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
+import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "./factory.js";
-export interface Node<W extends Gtk.Widget = Gtk.Widget> {
-    getWidget?(): W;
+export declare abstract class Node<T extends Gtk.Widget | undefined = Gtk.Widget | undefined> {
+    static matches(_type: string): boolean;
+    protected signalHandlers: Map<string, number>;
+    protected widget: T;
+    protected isVirtual(): boolean;
+    constructor(type: string, props: Props, currentApp?: unknown);
+    protected createWidget(type: string, props: Props, currentApp?: unknown): T;
+    getWidget(): T;
     appendChild(child: Node): void;
     removeChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-    mount(): void;
+    insertBefore(child: Node, _before: Node): void;
     attachToParent(parent: Node): void;
     detachFromParent(parent: Node): void;
-    dispose?(): void;
+    protected consumedProps(): Set<string>;
+    updateProps(oldProps: Props, newProps: Props): void;
+    protected setSignalProperty(widget: Gtk.Widget, key: string, handler: unknown): void;
+    protected setSignalHandler(widget: Gtk.Widget, eventName: string, handler: (...args: unknown[]) => unknown): void;
+    protected setProperty(widget: Gtk.Widget, key: string, value: unknown): void;
+    mount(): void;
+    dispose(): void;
 }

package/dist/node.js

@@ -1 +1,126 @@
-export {};
+import * as GObject from "@gtkx/ffi/gobject";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { CONSTRUCTOR_PARAMS } from "./generated/jsx.js";
+import { isAppendable, isRemovable, isSingleChild } from "./predicates.js";
+const extractConstructorArgs = (type, props) => {
+    const params = CONSTRUCTOR_PARAMS[type];
+    if (!params)
+        return [];
+    return params.map((p) => props[p.name]);
+};
+const normalizeType = (type) => (type.endsWith(".Root") ? type.slice(0, -5) : type);
+export class Node {
+    static matches(_type) {
+        return false;
+    }
+    signalHandlers = new Map();
+    widget;
+    isVirtual() {
+        return false;
+    }
+    constructor(type, props, currentApp) {
+        this.widget = (this.isVirtual() ? undefined : this.createWidget(type, props, currentApp));
+        this.updateProps({}, props);
+    }
+    createWidget(type, props, currentApp) {
+        const normalizedType = normalizeType(type);
+        const WidgetClass = Gtk[normalizedType];
+        if (!WidgetClass || typeof WidgetClass !== "function") {
+            throw new Error(`Unknown GTK widget type: ${normalizedType}`);
+        }
+        if (normalizedType === "ApplicationWindow") {
+            return new WidgetClass(currentApp);
+        }
+        const args = extractConstructorArgs(normalizedType, props);
+        return new WidgetClass(...args);
+    }
+    getWidget() {
+        return this.widget;
+    }
+    appendChild(child) {
+        child.attachToParent(this);
+    }
+    removeChild(child) {
+        child.detachFromParent(this);
+    }
+    insertBefore(child, _before) {
+        this.appendChild(child);
+    }
+    attachToParent(parent) {
+        const parentWidget = parent.getWidget();
+        const widget = this.getWidget();
+        if (!parentWidget || !widget)
+            return;
+        if (isAppendable(parentWidget)) {
+            parentWidget.append(widget);
+        }
+        else if (isSingleChild(parentWidget)) {
+            parentWidget.setChild(widget);
+        }
+    }
+    detachFromParent(parent) {
+        const parentWidget = parent.getWidget();
+        const widget = this.getWidget();
+        if (!parentWidget || !widget)
+            return;
+        if (isRemovable(parentWidget)) {
+            parentWidget.remove(widget);
+        }
+        else if (isSingleChild(parentWidget)) {
+            parentWidget.setChild(null);
+        }
+    }
+    consumedProps() {
+        return new Set(["children"]);
+    }
+    updateProps(oldProps, newProps) {
+        const widget = this.getWidget();
+        if (!widget)
+            return;
+        const consumed = this.consumedProps();
+        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+        for (const key of allKeys) {
+            if (consumed.has(key))
+                continue;
+            const oldValue = oldProps[key];
+            const newValue = newProps[key];
+            if (oldValue === newValue)
+                continue;
+            if (key.startsWith("on")) {
+                this.setSignalProperty(widget, key, newValue);
+                continue;
+            }
+            if (newValue === undefined)
+                continue;
+            this.setProperty(widget, key, newValue);
+        }
+    }
+    setSignalProperty(widget, key, handler) {
+        const eventName = key
+            .slice(2)
+            .replace(/([A-Z])/g, "-$1")
+            .toLowerCase()
+            .replace(/^-/, "");
+        const oldHandlerId = this.signalHandlers.get(eventName);
+        if (oldHandlerId !== undefined) {
+            GObject.signalHandlerDisconnect(widget, oldHandlerId);
+            this.signalHandlers.delete(eventName);
+        }
+        if (typeof handler === "function") {
+            this.setSignalHandler(widget, eventName, handler);
+        }
+    }
+    setSignalHandler(widget, eventName, handler) {
+        const handlerId = widget.connect(eventName, handler);
+        this.signalHandlers.set(eventName, handlerId);
+    }
+    setProperty(widget, key, value) {
+        const setterName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+        const setter = widget[setterName];
+        if (typeof setter === "function") {
+            setter.call(widget, value);
+        }
+    }
+    mount() { }
+    dispose() { }
+}

package/dist/nodes/dropdown.d.ts

@@ -1,41 +1,34 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-import { type Connectable, type ModelSettable, type Selectable } from "../widget-capabilities.js";
-type ItemLabelFn<T> = (item: T) => string;
-interface DropDownWidget extends Gtk.Widget, ModelSettable, Selectable, Connectable {
-}
-export declare class DropDownNode implements Node<DropDownWidget> {
-    static needsWidget: boolean;
-    static matches(type: string, widget: Gtk.Widget | null): widget is DropDownWidget;
-    private widget;
+import { Node } from "../node.js";
+type ItemLabelFn = (item: unknown) => string;
+declare class DropDownStore {
+    private stringList;
+    private items;
     private labelFn;
+    constructor(labelFn: ItemLabelFn);
+    getModel(): Gtk.StringList;
+    append(item: unknown): void;
+    remove(item: unknown): void;
+    getItem(index: number): unknown;
+    get length(): number;
+}
+export declare class DropDownNode extends Node<Gtk.DropDown> {
+    static matches(type: string): boolean;
+    private store;
     private onSelectionChanged?;
-    private signalHandlers;
-    constructor(_type: string, widget: Gtk.Widget, props: Props);
-    getWidget(): DropDownWidget;
-    getLabelFn(): ItemLabelFn<unknown>;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    insertBefore(child: Node, _before: Node): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(parent: Node): void;
+    constructor(type: string, props: Props, currentApp?: unknown);
+    getStore(): DropDownStore;
+    protected consumedProps(): Set<string>;
     updateProps(oldProps: Props, newProps: Props): void;
-    mount(): void;
-    dispose(): void;
 }
-export declare class DropDownItemNode<T = unknown> implements Node {
-    static needsWidget: boolean;
-    static matches(type: string, _widget: Gtk.Widget | null): _widget is Gtk.Widget;
+export declare class DropDownItemNode extends Node<never> {
+    static matches(type: string): boolean;
+    protected isVirtual(): boolean;
     private item;
-    constructor(_type: string, _widget: Gtk.Widget, props: Props);
-    getItem(): T;
-    appendChild(_child: Node): void;
-    removeChild(_child: Node): void;
-    insertBefore(_child: Node, _before: Node): void;
+    constructor(type: string, props: Props, _currentApp?: unknown);
+    getItem(): unknown;
     attachToParent(parent: Node): void;
     detachFromParent(parent: Node): void;
-    updateProps(_oldProps: Props, _newProps: Props): void;
-    mount(): void;
 }
 export {};

package/dist/nodes/dropdown.js

@@ -1,6 +1,5 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { appendChild, disconnectSignalHandlers, isConnectable, isModelSettable, isSelectable, removeChild, } from "../widget-capabilities.js";
-const isDropDownWidget = (widget) => isModelSettable(widget) && isSelectable(widget) && isConnectable(widget);
+import { Node } from "../node.js";
 class DropDownStore {
     stringList;
     items = [];
@@ -10,7 +9,7 @@ class DropDownStore {
         this.labelFn = labelFn;
     }
     getModel() {
-        return this.stringList.ptr;
+        return this.stringList;
     }
     append(item) {
         const label = this.labelFn(item);
@@ -31,133 +30,66 @@ class DropDownStore {
         return this.items.length;
     }
 }
-const dropdownStores = new WeakMap();
-const getOrCreateStore = (widget, labelFn) => {
-    let store = dropdownStores.get(widget);
-    if (!store) {
-        store = new DropDownStore(labelFn);
-        dropdownStores.set(widget, store);
-        widget.setModel(store.getModel());
-    }
-    return store;
-};
-export class DropDownNode {
-    static needsWidget = true;
-    static matches(type, widget) {
-        if (type !== "DropDown" && type !== "DropDown.Root")
-            return false;
-        return widget !== null && isDropDownWidget(widget);
-    }
-    widget;
-    labelFn;
+export class DropDownNode extends Node {
+    static matches(type) {
+        return type === "DropDown.Root";
+    }
+    store;
     onSelectionChanged;
-    signalHandlers = new Map();
-    constructor(_type, widget, props) {
-        if (!isDropDownWidget(widget)) {
-            throw new Error("DropDownNode requires a DropDown widget");
-        }
-        this.widget = widget;
-        this.labelFn = props.itemLabel ?? ((item) => String(item));
+    constructor(type, props, currentApp) {
+        super(type, props, currentApp);
+        const labelFn = props.itemLabel ?? ((item) => String(item));
         this.onSelectionChanged = props.onSelectionChanged;
-        getOrCreateStore(this.widget, this.labelFn);
+        this.store = new DropDownStore(labelFn);
+        this.widget.setModel(this.store.getModel());
         if (this.onSelectionChanged) {
             const handler = () => {
                 const index = this.widget.getSelected();
-                const store = dropdownStores.get(this.widget);
-                const item = store?.getItem(index);
+                const item = this.store.getItem(index);
                 this.onSelectionChanged?.(item, index);
             };
-            const handlerId = this.widget.connect("notify::selected", handler);
-            this.signalHandlers.set("notify::selected", handlerId);
+            this.setSignalHandler(this.widget, "notify::selected", handler);
         }
     }
-    getWidget() {
-        return this.widget;
-    }
-    getLabelFn() {
-        return this.labelFn;
-    }
-    appendChild(child) {
-        child.attachToParent(this);
-    }
-    removeChild(child) {
-        child.detachFromParent(this);
-    }
-    insertBefore(child, _before) {
-        this.appendChild(child);
-    }
-    attachToParent(parent) {
-        const parentWidget = parent.getWidget?.();
-        if (parentWidget) {
-            appendChild(parentWidget, this.widget);
-        }
+    getStore() {
+        return this.store;
     }
-    detachFromParent(parent) {
-        const parentWidget = parent.getWidget?.();
-        if (parentWidget) {
-            removeChild(parentWidget, this.widget);
-        }
+    consumedProps() {
+        const consumed = super.consumedProps();
+        consumed.add("itemLabel");
+        consumed.add("onSelectionChanged");
+        return consumed;
     }
     updateProps(oldProps, newProps) {
         if (oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
             this.onSelectionChanged = newProps.onSelectionChanged;
         }
-        const consumedProps = new Set(["children", "itemLabel", "onSelectionChanged"]);
-        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
-        for (const key of allKeys) {
-            if (consumedProps.has(key))
-                continue;
-            const oldValue = oldProps[key];
-            const newValue = newProps[key];
-            if (oldValue === newValue)
-                continue;
-            if (key.startsWith("on")) {
-                continue;
-            }
-            const setterName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-            const setter = this.widget[setterName];
-            if (typeof setter === "function") {
-                setter.call(this.widget, newValue);
-            }
-        }
-    }
-    mount() { }
-    dispose() {
-        disconnectSignalHandlers(this.widget, this.signalHandlers);
+        super.updateProps(oldProps, newProps);
     }
 }
-export class DropDownItemNode {
-    static needsWidget = false;
-    static matches(type, _widget) {
+export class DropDownItemNode extends Node {
+    static matches(type) {
         return type === "DropDown.Item";
     }
+    isVirtual() {
+        return true;
+    }
     item;
-    constructor(_type, _widget, props) {
+    constructor(type, props, _currentApp) {
+        super(type, props);
         this.item = props.item;
     }
     getItem() {
         return this.item;
     }
-    appendChild(_child) { }
-    removeChild(_child) { }
-    insertBefore(_child, _before) { }
     attachToParent(parent) {
         if (!(parent instanceof DropDownNode))
             return;
-        const widget = parent.getWidget();
-        const labelFn = parent.getLabelFn() ?? ((item) => String(item));
-        const store = getOrCreateStore(widget, labelFn);
-        store.append(this.item);
+        parent.getStore().append(this.item);
     }
     detachFromParent(parent) {
         if (!(parent instanceof DropDownNode))
             return;
-        const widget = parent.getWidget();
-        const store = dropdownStores.get(widget);
-        if (store) {
-            store.remove(this.item);
-        }
+        parent.getStore().remove(this.item);
     }
-    updateProps(_oldProps, _newProps) { }
-    mount() { }
 }

package/dist/nodes/grid.d.ts

@@ -1,41 +1,24 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-import { type GridAttachable, type Removable } from "../widget-capabilities.js";
-interface GridWidget extends Gtk.Widget, GridAttachable, Removable {
+import { Node } from "../node.js";
+export declare class GridNode extends Node<Gtk.Grid> {
+    static matches(type: string): boolean;
 }
-export declare class GridNode implements Node<GridWidget> {
-    static needsWidget: boolean;
-    static matches(type: string, widget: Gtk.Widget | null): widget is GridWidget;
-    private widget;
-    constructor(_type: string, widget: Gtk.Widget, _props: Props);
-    getWidget(): GridWidget;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    insertBefore(child: Node, _before: Node): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(parent: Node): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-    mount(): void;
-}
-export declare class GridChildNode implements Node {
-    static needsWidget: boolean;
-    static matches(type: string, _widget: Gtk.Widget | null): _widget is Gtk.Widget;
+export declare class GridChildNode extends Node<never> {
+    static matches(type: string): boolean;
+    protected isVirtual(): boolean;
     private column;
     private row;
     private columnSpan;
     private rowSpan;
     private childWidget;
     private parentGrid;
-    constructor(_type: string, _widget: Gtk.Widget, props: Props);
+    constructor(type: string, props: Props, _currentApp?: unknown);
     appendChild(child: Node): void;
     removeChild(child: Node): void;
-    insertBefore(child: Node, _before: Node): void;
     private attachChildToGrid;
     private detachChildFromGrid;
     attachToParent(parent: Node): void;
     detachFromParent(parent: Node): void;
     updateProps(oldProps: Props, newProps: Props): void;
-    mount(): void;
 }
-export {};

package/dist/nodes/grid.js

@@ -1,84 +1,31 @@
-import { appendChild, isGridAttachable, isRemovable, removeChild, } from "../widget-capabilities.js";
-const isGridWidget = (widget) => isGridAttachable(widget) && isRemovable(widget);
-export class GridNode {
-    static needsWidget = true;
-    static matches(type, widget) {
-        if (type !== "Grid" && type !== "Grid.Root")
-            return false;
-        return widget !== null && isGridWidget(widget);
+import { Node } from "../node.js";
+export class GridNode extends Node {
+    static matches(type) {
+        return type === "Grid.Root";
     }
-    widget;
-    constructor(_type, widget, _props) {
-        if (!isGridWidget(widget)) {
-            throw new Error("GridNode requires a Grid widget");
-        }
-        this.widget = widget;
-    }
-    getWidget() {
-        return this.widget;
-    }
-    appendChild(child) {
-        child.attachToParent(this);
-    }
-    removeChild(child) {
-        child.detachFromParent(this);
-    }
-    insertBefore(child, _before) {
-        this.appendChild(child);
-    }
-    attachToParent(parent) {
-        const parentWidget = parent.getWidget?.();
-        if (parentWidget) {
-            appendChild(parentWidget, this.widget);
-        }
-    }
-    detachFromParent(parent) {
-        const parentWidget = parent.getWidget?.();
-        if (parentWidget) {
-            removeChild(parentWidget, this.widget);
-        }
-    }
-    updateProps(oldProps, newProps) {
-        const consumedProps = new Set(["children"]);
-        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
-        for (const key of allKeys) {
-            if (consumedProps.has(key))
-                continue;
-            const oldValue = oldProps[key];
-            const newValue = newProps[key];
-            if (oldValue === newValue)
-                continue;
-            if (key.startsWith("on")) {
-                continue;
-            }
-            const setterName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-            const setter = this.widget[setterName];
-            if (typeof setter === "function") {
-                setter.call(this.widget, newValue);
-            }
-        }
-    }
-    mount() { }
 }
-export class GridChildNode {
-    static needsWidget = false;
-    static matches(type, _widget) {
+export class GridChildNode extends Node {
+    static matches(type) {
         return type === "Grid.Child";
     }
+    isVirtual() {
+        return true;
+    }
     column;
     row;
     columnSpan;
     rowSpan;
     childWidget = null;
     parentGrid = null;
-    constructor(_type, _widget, props) {
+    constructor(type, props, _currentApp) {
+        super(type, props);
         this.column = props.column ?? 0;
         this.row = props.row ?? 0;
         this.columnSpan = props.columnSpan ?? 1;
         this.rowSpan = props.rowSpan ?? 1;
     }
     appendChild(child) {
-        const widget = child.getWidget?.();
+        const widget = child.getWidget();
         if (widget) {
             this.childWidget = widget;
             if (this.parentGrid) {
@@ -87,26 +34,27 @@ export class GridChildNode {
         }
     }
     removeChild(child) {
-        const widget = child.getWidget?.();
+        const widget = child.getWidget();
         if (widget && this.childWidget === widget) {
             this.detachChildFromGrid();
             this.childWidget = null;
         }
     }
-    insertBefore(child, _before) {
-        this.appendChild(child);
-    }
     attachChildToGrid() {
         if (!this.parentGrid || !this.childWidget)
             return;
         const grid = this.parentGrid.getWidget();
-        grid.attach(this.childWidget.ptr, this.column, this.row, this.columnSpan, this.rowSpan);
+        if (!grid)
+            return;
+        grid.attach(this.childWidget, this.column, this.row, this.columnSpan, this.rowSpan);
     }
     detachChildFromGrid() {
         if (!this.parentGrid || !this.childWidget)
             return;
         const grid = this.parentGrid.getWidget();
-        grid.remove(this.childWidget.ptr);
+        if (!grid)
+            return;
+        grid.remove(this.childWidget);
     }
     attachToParent(parent) {
         if (parent instanceof GridNode) {
@@ -136,5 +84,4 @@ export class GridChildNode {
             this.attachChildToGrid();
         }
     }
-    mount() { }
 }

package/dist/nodes/list.d.ts

@@ -1,46 +1,27 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-interface ListViewWidget extends Gtk.Widget {
-    setModel(model: unknown): void;
-    setFactory(factory: unknown): void;
-}
-export declare class ListViewNode<T = unknown> implements Node<ListViewWidget> {
-    static needsWidget: boolean;
-    static matches(type: string, widget: Gtk.Widget | null): widget is ListViewWidget;
-    private widget;
+import { Node } from "../node.js";
+export declare class ListViewNode extends Node<Gtk.ListView> {
+    static matches(type: string): boolean;
     private stringList;
     private selectionModel;
     private factory;
     private items;
     private renderItem;
-    private signalHandlers;
     private factorySignalHandlers;
-    constructor(_type: string, widget: Gtk.Widget, props: Props);
-    getWidget(): ListViewWidget;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    insertBefore(child: Node, _before: Node): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(parent: Node): void;
-    addItem(item: T): void;
-    removeItem(item: T): void;
+    constructor(type: string, props: Props, currentApp?: unknown);
+    addItem(item: unknown): void;
+    removeItem(item: unknown): void;
+    protected consumedProps(): Set<string>;
     updateProps(oldProps: Props, newProps: Props): void;
-    mount(): void;
     dispose(): void;
 }
-export declare class ListItemNode<T = unknown> implements Node {
-    static needsWidget: boolean;
-    static matches(type: string, _widget: Gtk.Widget | null): _widget is Gtk.Widget;
+export declare class ListItemNode extends Node {
+    static matches(type: string): boolean;
+    protected isVirtual(): boolean;
     private item;
-    constructor(_type: string, _widget: Gtk.Widget, props: Props);
-    getItem(): T;
-    appendChild(_child: Node): void;
-    removeChild(_child: Node): void;
-    insertBefore(_child: Node, _before: Node): void;
+    constructor(type: string, props: Props, _currentApp?: unknown);
+    getItem(): unknown;
     attachToParent(parent: Node): void;
     detachFromParent(parent: Node): void;
-    updateProps(_oldProps: Props, _newProps: Props): void;
-    mount(): void;
 }
-export {};