@gtkx/react 0.1.11

package/dist/nodes/dropdown.js

@@ -0,0 +1,163 @@
+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);
+class DropDownStore {
+    stringList;
+    items = [];
+    labelFn;
+    constructor(labelFn) {
+        this.stringList = new Gtk.StringList([]);
+        this.labelFn = labelFn;
+    }
+    getModel() {
+        return this.stringList.ptr;
+    }
+    append(item) {
+        const label = this.labelFn(item);
+        this.stringList.append(label);
+        this.items.push(item);
+    }
+    remove(item) {
+        const index = this.items.indexOf(item);
+        if (index !== -1) {
+            this.stringList.remove(index);
+            this.items.splice(index, 1);
+        }
+    }
+    getItem(index) {
+        return this.items[index];
+    }
+    get length() {
+        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;
+    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));
+        this.onSelectionChanged = props.onSelectionChanged;
+        getOrCreateStore(this.widget, this.labelFn);
+        if (this.onSelectionChanged) {
+            const handler = () => {
+                const index = this.widget.getSelected();
+                const store = dropdownStores.get(this.widget);
+                const item = store?.getItem(index);
+                this.onSelectionChanged?.(item, index);
+            };
+            const handlerId = this.widget.connect("notify::selected", handler);
+            this.signalHandlers.set("notify::selected", handlerId);
+        }
+    }
+    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);
+        }
+    }
+    detachFromParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            removeChild(parentWidget, this.widget);
+        }
+    }
+    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);
+    }
+}
+export class DropDownItemNode {
+    static needsWidget = false;
+    static matches(type, _widget) {
+        return type === "DropDown.Item";
+    }
+    item;
+    constructor(_type, _widget, 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);
+    }
+    detachFromParent(parent) {
+        if (!(parent instanceof DropDownNode))
+            return;
+        const widget = parent.getWidget();
+        const store = dropdownStores.get(widget);
+        if (store) {
+            store.remove(this.item);
+        }
+    }
+    updateProps(_oldProps, _newProps) { }
+    mount() { }
+}

package/dist/nodes/grid.d.ts

@@ -0,0 +1,41 @@
+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 {
+}
+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;
+    private column;
+    private row;
+    private columnSpan;
+    private rowSpan;
+    private childWidget;
+    private parentGrid;
+    constructor(_type: string, _widget: Gtk.Widget, props: Props);
+    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

@@ -0,0 +1,140 @@
+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);
+    }
+    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) {
+        return type === "Grid.Child";
+    }
+    column;
+    row;
+    columnSpan;
+    rowSpan;
+    childWidget = null;
+    parentGrid = null;
+    constructor(_type, _widget, 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?.();
+        if (widget) {
+            this.childWidget = widget;
+            if (this.parentGrid) {
+                this.attachChildToGrid();
+            }
+        }
+    }
+    removeChild(child) {
+        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);
+    }
+    detachChildFromGrid() {
+        if (!this.parentGrid || !this.childWidget)
+            return;
+        const grid = this.parentGrid.getWidget();
+        grid.remove(this.childWidget.ptr);
+    }
+    attachToParent(parent) {
+        if (parent instanceof GridNode) {
+            this.parentGrid = parent;
+            if (this.childWidget) {
+                this.attachChildToGrid();
+            }
+        }
+    }
+    detachFromParent(parent) {
+        if (parent instanceof GridNode) {
+            this.detachChildFromGrid();
+            this.parentGrid = null;
+        }
+    }
+    updateProps(oldProps, newProps) {
+        const positionChanged = oldProps.column !== newProps.column ||
+            oldProps.row !== newProps.row ||
+            oldProps.columnSpan !== newProps.columnSpan ||
+            oldProps.rowSpan !== newProps.rowSpan;
+        if (positionChanged) {
+            this.detachChildFromGrid();
+            this.column = newProps.column ?? 0;
+            this.row = newProps.row ?? 0;
+            this.columnSpan = newProps.columnSpan ?? 1;
+            this.rowSpan = newProps.rowSpan ?? 1;
+            this.attachChildToGrid();
+        }
+    }
+    mount() { }
+}

package/dist/nodes/list.d.ts

@@ -0,0 +1,46 @@
+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;
+    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;
+    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;
+    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;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+    updateProps(_oldProps: Props, _newProps: Props): void;
+    mount(): void;
+}
+export {};

package/dist/nodes/list.js

@@ -0,0 +1,165 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { appendChild, disconnectSignalHandlers, isConnectable, removeChild } from "../widget-capabilities.js";
+const isListViewWidget = (widget) => "setModel" in widget &&
+    typeof widget.setModel === "function" &&
+    "setFactory" in widget &&
+    typeof widget.setFactory === "function";
+const LIST_VIEW_TYPES = ["ListView", "ListView.Root"];
+export class ListViewNode {
+    static needsWidget = true;
+    static matches(type, widget) {
+        if (!LIST_VIEW_TYPES.includes(type) && !type.startsWith("ListView"))
+            return false;
+        return widget !== null && isListViewWidget(widget);
+    }
+    widget;
+    stringList;
+    selectionModel;
+    factory;
+    items = [];
+    renderItem = null;
+    signalHandlers = new Map();
+    factorySignalHandlers = new Map();
+    constructor(_type, widget, props) {
+        if (!isListViewWidget(widget)) {
+            throw new Error("ListViewNode requires a ListView widget");
+        }
+        this.widget = widget;
+        this.stringList = new Gtk.StringList([]);
+        this.selectionModel = new Gtk.SingleSelection(this.stringList);
+        this.factory = new Gtk.SignalListItemFactory();
+        this.renderItem = props.renderItem;
+        const setupHandlerId = this.factory.connect("setup", (listItemPtr) => {
+            const listItem = Object.create(Gtk.ListItem.prototype);
+            listItem.ptr = listItemPtr;
+            if (this.renderItem) {
+                const widget = this.renderItem(null);
+                listItem.setChild(widget);
+            }
+        });
+        this.factorySignalHandlers.set("setup", setupHandlerId);
+        const bindHandlerId = this.factory.connect("bind", (listItemPtr) => {
+            const listItem = Object.create(Gtk.ListItem.prototype);
+            listItem.ptr = listItemPtr;
+            const position = listItem.getPosition();
+            const item = this.items[position];
+            if (this.renderItem && item !== undefined) {
+                const widget = this.renderItem(item);
+                listItem.setChild(widget);
+            }
+        });
+        this.factorySignalHandlers.set("bind", bindHandlerId);
+        this.widget.setModel(this.selectionModel.ptr);
+        this.widget.setFactory(this.factory.ptr);
+    }
+    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);
+        }
+    }
+    addItem(item) {
+        this.items.push(item);
+        this.stringList.append("");
+    }
+    removeItem(item) {
+        const index = this.items.indexOf(item);
+        if (index !== -1) {
+            this.items.splice(index, 1);
+            this.stringList.remove(index);
+        }
+    }
+    updateProps(oldProps, newProps) {
+        if (oldProps.renderItem !== newProps.renderItem) {
+            this.renderItem = newProps.renderItem;
+        }
+        const consumedProps = new Set(["children", "renderItem"]);
+        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")) {
+                const eventName = key
+                    .slice(2)
+                    .replace(/([A-Z])/g, "-$1")
+                    .toLowerCase()
+                    .replace(/^-/, "");
+                const oldHandlerId = this.signalHandlers.get(eventName);
+                if (oldHandlerId !== undefined && isConnectable(this.widget)) {
+                    this.signalHandlers.delete(eventName);
+                }
+                if (typeof newValue === "function" && isConnectable(this.widget)) {
+                    const handlerId = this.widget.connect(eventName, newValue);
+                    this.signalHandlers.set(eventName, handlerId);
+                }
+                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);
+        disconnectSignalHandlers(this.factory, this.factorySignalHandlers);
+    }
+}
+const LIST_WIDGETS = ["ListView", "ColumnView", "GridView"];
+export class ListItemNode {
+    static needsWidget = false;
+    static matches(type, _widget) {
+        const dotIndex = type.indexOf(".");
+        if (dotIndex === -1)
+            return false;
+        const widgetType = type.slice(0, dotIndex);
+        const suffix = type.slice(dotIndex + 1);
+        return suffix === "Item" && LIST_WIDGETS.includes(widgetType);
+    }
+    item;
+    constructor(_type, _widget, props) {
+        this.item = props.item;
+    }
+    getItem() {
+        return this.item;
+    }
+    appendChild(_child) { }
+    removeChild(_child) { }
+    insertBefore(_child, _before) { }
+    attachToParent(parent) {
+        if (parent instanceof ListViewNode) {
+            parent.addItem(this.item);
+        }
+    }
+    detachFromParent(parent) {
+        if (parent instanceof ListViewNode) {
+            parent.removeItem(this.item);
+        }
+    }
+    updateProps(_oldProps, _newProps) { }
+    mount() { }
+}

package/dist/nodes/notebook.d.ts

@@ -0,0 +1,25 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+import { type NotebookLike } from "../widget-capabilities.js";
+interface NotebookWidget extends Gtk.Widget, NotebookLike {
+}
+export declare class NotebookNode implements Node<NotebookWidget> {
+    static needsWidget: boolean;
+    static matches(type: string, widget: Gtk.Widget | null): widget is NotebookWidget;
+    private widget;
+    private signalHandlers;
+    constructor(_type: string, widget: Gtk.Widget, _props: Props);
+    getWidget(): NotebookWidget;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    insertBefore(child: Node, _before: Node): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+    attachChild(childWidget: Gtk.Widget): void;
+    detachChild(childWidget: Gtk.Widget): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+    mount(): void;
+    dispose(): void;
+}
+export {};

package/dist/nodes/notebook.js

@@ -0,0 +1,88 @@
+import { appendChild, disconnectSignalHandlers, isConnectable, isNotebookLike, removeChild, } from "../widget-capabilities.js";
+const isNotebookWidget = (widget) => isNotebookLike(widget);
+export class NotebookNode {
+    static needsWidget = true;
+    static matches(type, widget) {
+        if (type !== "Notebook" && type !== "Notebook.Root")
+            return false;
+        return widget !== null && isNotebookWidget(widget);
+    }
+    widget;
+    signalHandlers = new Map();
+    constructor(_type, widget, _props) {
+        if (!isNotebookWidget(widget)) {
+            throw new Error("NotebookNode requires a Notebook 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);
+        }
+    }
+    attachChild(childWidget) {
+        this.widget.appendPage(childWidget.ptr, undefined);
+    }
+    detachChild(childWidget) {
+        const pageNum = this.widget.pageNum(childWidget.ptr);
+        if (pageNum >= 0) {
+            this.widget.removePage(pageNum);
+        }
+    }
+    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")) {
+                const eventName = key
+                    .slice(2)
+                    .replace(/([A-Z])/g, "-$1")
+                    .toLowerCase()
+                    .replace(/^-/, "");
+                const oldHandlerId = this.signalHandlers.get(eventName);
+                if (oldHandlerId !== undefined && isConnectable(this.widget)) {
+                    this.signalHandlers.delete(eventName);
+                }
+                if (typeof newValue === "function" && isConnectable(this.widget)) {
+                    const handlerId = this.widget.connect(eventName, newValue);
+                    this.signalHandlers.set(eventName, handlerId);
+                }
+                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);
+    }
+}

package/dist/nodes/overlay.d.ts

@@ -0,0 +1,29 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+interface OverlayWidget extends Gtk.Widget {
+    setChild(child: unknown): void;
+    addOverlay(widget: unknown): void;
+    removeOverlay(widget: unknown): void;
+}
+export declare class OverlayNode implements Node<OverlayWidget> {
+    static needsWidget: boolean;
+    static matches(type: string, widget: Gtk.Widget | null): widget is OverlayWidget;
+    private widget;
+    private mainChild;
+    private overlayChildren;
+    private signalHandlers;
+    constructor(_type: string, widget: Gtk.Widget, _props: Props);
+    getWidget(): OverlayWidget;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    insertBefore(child: Node, _before: Node): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+    attachChild(childWidget: Gtk.Widget): void;
+    detachChild(childWidget: Gtk.Widget): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+    mount(): void;
+    dispose(): void;
+}
+export {};