@gtkx/react 0.9.4 → 0.10.0

package/dist/node.js

@@ -1,246 +1,26 @@
-import * as Adw from "@gtkx/ffi/adw";
-import * as GObject from "@gtkx/ffi/gobject";
-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 { CONSTRUCTOR_PARAMS, PROP_SETTERS, SETTER_GETTERS } from "./generated/internal.js";
-import { isAddable, isAppendable, isChildContainer, isRemovable, isSingleChild } from "./predicates.js";
-export const normalizeWidgetType = (type) => type.split(".")[0] || type;
-const NAMESPACE_REGISTRY = [
-    ["GtkSource", GtkSource],
-    ["WebKit", WebKit],
-    ["Adw", Adw],
-    ["Vte", Vte],
-];
-const resolveWidgetClass = (type) => {
-    for (const [prefix, namespace] of NAMESPACE_REGISTRY) {
-        if (type.startsWith(prefix)) {
-            const className = type.slice(prefix.length);
-            return namespace[className];
-        }
-    }
-    // biome-ignore lint/performance/noDynamicNamespaceImportAccess: dynamic widget resolution by name
-    return Gtk[type];
-};
-const extractConstructorArgs = (type, props) => {
-    const params = CONSTRUCTOR_PARAMS[type];
-    if (!params)
-        return [];
-    return params.map((p) => props[p.name]);
-};
+import { SignalStore } from "./nodes/internal/signal-store.js";
 export class Node {
-    static matches(_type, _widget) {
-        return false;
-    }
-    static consumedPropNames = [];
-    signalHandlers = new Map();
-    widget = undefined;
-    widgetType;
-    nodeType;
-    parent = null;
-    _state = null;
-    get state() {
-        if (this._state === null) {
-            throw new Error(`${this.constructor.name} not initialized`);
-        }
-        return this._state;
-    }
-    set state(value) {
-        this._state = value;
-    }
-    isVirtual() {
-        return false;
-    }
-    isStandalone() {
+    static priority = 0;
+    static matches(_type, _containerOrClass) {
         return false;
     }
-    constructor(type, widget) {
-        this.nodeType = type;
-        this.widgetType = normalizeWidgetType(type);
-        if (widget) {
-            this.widget = widget;
-        }
-    }
-    initialize(props) {
-        if (!this.widget && !this.isVirtual()) {
-            this.widget = this.createWidget(this.nodeType, props);
-        }
-        this.updateProps({}, props);
-    }
-    createWidget(type, props) {
-        const widgetType = normalizeWidgetType(type);
-        const WidgetClass = resolveWidgetClass(widgetType);
-        if (!WidgetClass) {
-            throw new Error(`Unknown GTK widget type: ${widgetType}`);
-        }
-        return new WidgetClass(...extractConstructorArgs(widgetType, props));
-    }
-    getWidget() {
-        return this.widget;
-    }
-    appendChild(child) {
-        child.parent = this;
-        const childWidget = child.getWidget();
-        if (!childWidget || child.isStandalone())
-            return;
-        if (isChildContainer(this)) {
-            this.attachChild(childWidget);
-        }
-        else if (this.widget && isAppendable(this.widget)) {
-            childWidget.insertBefore(this.widget);
-        }
-        else if (this.widget && isAddable(this.widget)) {
-            this.widget.add(childWidget);
-        }
-        else if (this.widget && isSingleChild(this.widget)) {
-            this.widget.setChild(childWidget);
-        }
-    }
-    removeChild(child) {
-        child.unmount();
-        const childWidget = child.getWidget();
-        if (childWidget) {
-            if (isChildContainer(this)) {
-                this.detachChild(childWidget);
-            }
-            else if (this.widget && isRemovable(this.widget)) {
-                this.widget.remove(childWidget);
-            }
-            else if (this.widget && isSingleChild(this.widget)) {
-                this.widget.setChild(null);
-            }
-        }
-        child.parent = null;
-    }
-    insertBefore(child, before) {
-        child.parent = this;
-        const childWidget = child.getWidget();
-        const beforeWidget = before.getWidget();
-        if (!childWidget || child.isStandalone())
-            return;
-        if (isChildContainer(this)) {
-            if (beforeWidget) {
-                this.insertChildBefore(childWidget, beforeWidget);
-            }
-            else {
-                this.attachChild(childWidget);
-            }
-        }
-        else if (this.widget && isAppendable(this.widget) && beforeWidget) {
-            childWidget.insertBefore(this.widget, beforeWidget);
-        }
-        else {
-            this.appendChild(child);
-        }
-    }
+    static createContainer(_props, _containerClass, _rootContainer) {
+        throw new Error("Cannot create container: unsupported node type");
+    }
+    container;
+    typeName;
+    signalStore;
+    constructor(typeName, _props = {}, container, _rootContainer) {
+        this.typeName = typeName;
+        this.container = container;
+        this.signalStore = new SignalStore();
+    }
+    appendChild(_child) { }
+    removeChild(_child) { }
+    insertBefore(_child, _before) { }
+    updateProps(_oldProps, _newProps) { }
+    mount() { }
     unmount() {
-        this.disconnectAllSignals();
-    }
-    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;
-    }
-    consumedProps() {
-        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;
+        this.signalStore.clear();
     }
-    updateProps(oldProps, newProps) {
-        const widget = this.getWidget();
-        if (!widget)
-            return;
-        const consumed = this.consumedProps();
-        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
-        const signalUpdates = [];
-        const propertyUpdates = [];
-        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")) {
-                signalUpdates.push({ key, newValue });
-            }
-            else if (newValue !== undefined) {
-                propertyUpdates.push({ key, newValue });
-            }
-        }
-        for (const { key } of signalUpdates) {
-            this.disconnectSignal(this.propKeyToEventName(key));
-        }
-        if (propertyUpdates.length > 0) {
-            widget.freezeNotify();
-        }
-        for (const { key, newValue } of propertyUpdates) {
-            this.setProperty(widget, key, newValue);
-        }
-        if (propertyUpdates.length > 0) {
-            widget.thawNotify();
-        }
-        for (const { key, newValue } of signalUpdates) {
-            if (typeof newValue === "function") {
-                this.connectSignal(widget, this.propKeyToEventName(key), newValue);
-            }
-        }
-    }
-    propKeyToEventName(key) {
-        return key
-            .slice(2)
-            .replace(/([A-Z])/g, "-$1")
-            .toLowerCase()
-            .replace(/^-/, "");
-    }
-    disconnectSignal(eventName) {
-        const handlerId = this.signalHandlers.get(eventName);
-        if (handlerId !== undefined) {
-            const widget = this.getWidget();
-            if (widget) {
-                GObject.signalHandlerDisconnect(widget, handlerId);
-            }
-            this.signalHandlers.delete(eventName);
-        }
-    }
-    connectSignal(widget, eventName, handler) {
-        const handlerId = widget.connect(eventName, handler);
-        this.signalHandlers.set(eventName, handlerId);
-    }
-    setProperty(widget, key, value) {
-        const setterName = PROP_SETTERS[this.widgetType]?.[key];
-        if (!setterName)
-            return;
-        const setter = widget[setterName];
-        if (typeof setter !== "function")
-            return;
-        const getterName = SETTER_GETTERS[this.widgetType]?.[setterName];
-        if (getterName) {
-            const getter = widget[getterName];
-            if (typeof getter === "function") {
-                const currentValue = getter.call(widget);
-                if (currentValue === value)
-                    return;
-            }
-        }
-        setter.call(widget, value);
-    }
-    mount() { }
 }

package/dist/nodes/action-row-child.d.ts

@@ -0,0 +1,21 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+type PrefixSuffixWidget = Gtk.Widget & {
+    addPrefix(child: Gtk.Widget): void;
+    addSuffix(child: Gtk.Widget): void;
+    remove(child: Gtk.Widget): void;
+};
+export declare class ActionRowChild extends VirtualNode {
+    static priority: number;
+    static matches(type: string): boolean;
+    private parent?;
+    private children;
+    private getPosition;
+    setParent(newParent?: PrefixSuffixWidget): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node): void;
+    removeChild(child: Node): void;
+    unmount(): void;
+}
+export {};

package/dist/nodes/action-row-child.js

@@ -0,0 +1,69 @@
+import { registerNodeClass } from "../registry.js";
+import { scheduleAfterCommit } from "../scheduler.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class ActionRowChild extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ActionRow.Prefix" || type === "ActionRow.Suffix";
+    }
+    parent;
+    children = [];
+    getPosition() {
+        return this.typeName === "ActionRow.Prefix" ? "prefix" : "suffix";
+    }
+    setParent(newParent) {
+        this.parent = newParent;
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        this.children.push(widget);
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                if (this.getPosition() === "prefix") {
+                    this.parent.addPrefix(widget);
+                }
+                else {
+                    this.parent.addSuffix(widget);
+                }
+            }
+        });
+    }
+    insertBefore(child) {
+        this.appendChild(child);
+    }
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        const parent = this.parent;
+        const index = this.children.indexOf(widget);
+        if (index !== -1) {
+            this.children.splice(index, 1);
+        }
+        scheduleAfterCommit(() => {
+            if (parent) {
+                parent.remove(widget);
+            }
+        });
+    }
+    unmount() {
+        const parent = this.parent;
+        const childrenToRemove = [...this.children];
+        if (parent && childrenToRemove.length > 0) {
+            scheduleAfterCommit(() => {
+                for (const widget of childrenToRemove) {
+                    parent.remove(widget);
+                }
+            });
+        }
+        this.children = [];
+        this.parent = undefined;
+        super.unmount();
+    }
+}
+registerNodeClass(ActionRowChild);

package/dist/nodes/action-row.js

@@ -0,0 +1,33 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { ActionRowChild } from "./action-row-child.js";
+import { WidgetNode } from "./widget.js";
+class ActionRowNode extends WidgetNode {
+    static priority = 0;
+    static matches(_type, containerOrClass) {
+        if (!containerOrClass ||
+            (typeof containerOrClass !== "function" && !(containerOrClass instanceof Gtk.Widget))) {
+            return false;
+        }
+        const protoOrInstance = typeof containerOrClass === "function" ? containerOrClass.prototype : containerOrClass;
+        return "addPrefix" in protoOrInstance && "addSuffix" in protoOrInstance && "remove" in protoOrInstance;
+    }
+    appendChild(child) {
+        if (child instanceof ActionRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child) {
+        this.appendChild(child);
+    }
+    removeChild(child) {
+        if (child instanceof ActionRowChild) {
+            child.unmount();
+            return;
+        }
+        super.removeChild(child);
+    }
+}
+registerNodeClass(ActionRowNode);

package/dist/nodes/application.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/application.js

@@ -0,0 +1,38 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { Node } from "../node.js";
+import { registerNodeClass } from "../registry.js";
+import { isContainerType } from "./internal/utils.js";
+import { MenuNode } from "./menu.js";
+import { Menu } from "./models/menu.js";
+class ApplicationNode extends Node {
+    static priority = 0;
+    menu;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.Application, containerOrClass);
+    }
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
+        this.menu = new Menu("root", {}, container, application);
+    }
+    appendChild(child) {
+        if (child instanceof MenuNode) {
+            this.menu.appendChild(child);
+            this.container.setMenubar(this.menu.getMenu());
+        }
+    }
+    insertBefore(child, before) {
+        if (child instanceof MenuNode) {
+            this.menu.insertBefore(child, before);
+        }
+    }
+    removeChild(child) {
+        if (child instanceof MenuNode) {
+            this.menu.removeChild(child);
+            if (this.menu.getMenu().getNItems() === 0) {
+                this.container.setMenubar(undefined);
+            }
+        }
+    }
+}
+registerNodeClass(ApplicationNode);

package/dist/nodes/autowrapped.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/autowrapped.js

@@ -0,0 +1,109 @@
+import { batch } from "@gtkx/ffi";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { isRemovable, isSingleChild } from "./internal/predicates.js";
+import { isContainerType } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const isAutowrappedChild = (obj) => {
+    return obj instanceof Gtk.ListBoxRow || obj instanceof Gtk.FlowBoxChild;
+};
+class AutowrappedNode extends WidgetNode {
+    static priority = 2;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.ListBox, containerOrClass) || isContainerType(Gtk.FlowBox, containerOrClass);
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            super.appendChild(child);
+            return;
+        }
+        batch(() => {
+            if (isAutowrappedChild(child.container)) {
+                const currentParent = child.container.getParent();
+                if (currentParent !== null && isRemovable(currentParent)) {
+                    currentParent.remove(child.container);
+                }
+            }
+            else {
+                this.removeExistingWrapper(child.container);
+            }
+            this.container.append(child.container);
+        });
+    }
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            super.removeChild(child);
+            return;
+        }
+        batch(() => {
+            if (!isAutowrappedChild(child.container)) {
+                const wrapper = child.container.getParent();
+                if (wrapper && isSingleChild(wrapper)) {
+                    wrapper.setChild(null);
+                    this.container.remove(wrapper);
+                    return;
+                }
+            }
+            this.container.remove(child.container);
+        });
+    }
+    insertBefore(child, before) {
+        if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
+            super.insertBefore(child, before);
+            return;
+        }
+        batch(() => {
+            const currentParent = child.container.getParent();
+            if (currentParent !== null) {
+                if (isAutowrappedChild(child.container)) {
+                    if (isRemovable(currentParent)) {
+                        currentParent.remove(child.container);
+                    }
+                }
+                else {
+                    this.removeExistingWrapper(child.container);
+                }
+            }
+            else if (!isAutowrappedChild(child.container)) {
+                this.removeExistingWrapper(child.container);
+            }
+            const position = this.findChildPosition(before);
+            if (position !== undefined) {
+                this.container.insert(child.container, position);
+            }
+            else {
+                this.container.append(child.container);
+            }
+        });
+    }
+    removeExistingWrapper(childWidget) {
+        const existingWrapper = childWidget.getParent();
+        if (existingWrapper && isSingleChild(existingWrapper)) {
+            existingWrapper.setChild(null);
+            const wrapperParent = existingWrapper.getParent();
+            if (wrapperParent !== null && isRemovable(wrapperParent)) {
+                wrapperParent.remove(existingWrapper);
+            }
+        }
+    }
+    findChildPosition(before) {
+        let position = 0;
+        let currentChild = this.container.getFirstChild();
+        const beforeIsWrapper = isAutowrappedChild(before.container);
+        while (currentChild) {
+            const widgetToCompare = beforeIsWrapper ? currentChild : this.unwrapChild(currentChild);
+            if (widgetToCompare?.equals(before.container)) {
+                return position;
+            }
+            position++;
+            currentChild = currentChild.getNextSibling();
+        }
+    }
+    unwrapChild(child) {
+        if ("getChild" in child && typeof child.getChild === "function") {
+            return child.getChild();
+        }
+        return child;
+    }
+}
+registerNodeClass(AutowrappedNode);

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

@@ -0,0 +1,16 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { ColumnViewColumnProps } from "../jsx.js";
+import type { Container } from "../types.js";
+import type { ListStore } from "./internal/list-store.js";
+import { VirtualNode } from "./virtual.js";
+type Props = Partial<ColumnViewColumnProps>;
+export declare class ColumnViewColumnNode extends VirtualNode<Props> {
+    static priority: number;
+    static matches(type: string): boolean;
+    column: Gtk.ColumnViewColumn;
+    private itemRenderer;
+    constructor(typeName: string, props: Props, container: undefined, rootContainer?: Container);
+    setStore(model?: ListStore): void;
+    updateProps(oldProps: Props | null, newProps: Props): void;
+}
+export {};

package/dist/nodes/column-view-column.js

@@ -0,0 +1,54 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { ListItemRenderer } from "./internal/list-item-renderer.js";
+import { VirtualNode } from "./virtual.js";
+export class ColumnViewColumnNode extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ColumnViewColumn";
+    }
+    column;
+    itemRenderer;
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        this.itemRenderer = new ListItemRenderer(this.signalStore);
+        this.column = new Gtk.ColumnViewColumn();
+        this.column.setFactory(this.itemRenderer.getFactory());
+    }
+    setStore(model) {
+        this.itemRenderer.setStore(model);
+    }
+    updateProps(oldProps, newProps) {
+        if (!oldProps || oldProps.renderCell !== newProps.renderCell) {
+            if (newProps.renderCell) {
+                this.itemRenderer.setRenderFn(newProps.renderCell);
+            }
+        }
+        if (!oldProps || oldProps.title !== newProps.title) {
+            this.column.setTitle(newProps.title ?? "");
+        }
+        if (!oldProps || oldProps.expand !== newProps.expand) {
+            this.column.setExpand(newProps.expand ?? false);
+        }
+        if (!oldProps || oldProps.resizable !== newProps.resizable) {
+            this.column.setResizable(newProps.resizable ?? false);
+        }
+        if (!oldProps || oldProps.fixedWidth !== newProps.fixedWidth) {
+            this.column.setFixedWidth(newProps.fixedWidth ?? -1);
+        }
+        if (!oldProps || oldProps.id !== newProps.id) {
+            if (newProps.id) {
+                this.column.setId(newProps.id);
+            }
+        }
+        if (!oldProps || oldProps.sortable !== newProps.sortable) {
+            if (newProps.sortable) {
+                this.column.setSorter(new Gtk.StringSorter());
+            }
+            else {
+                this.column.setSorter(undefined);
+            }
+        }
+    }
+}
+registerNodeClass(ColumnViewColumnNode);

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

@@ -1,60 +1 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { StringSorter } from "@gtkx/ffi/gtk";
-import type { ColumnContainer } from "../containers.js";
-import type { Props } from "../factory.js";
-import { Node } from "../node.js";
-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[];
-    sortColumn: string | null;
-    sortOrder: Gtk.SortType;
-    onSortChange: ((column: string | null, order: Gtk.SortType) => void) | null;
-    sorterChangedHandlerId: number | null;
-    lastNotifiedColumn: string | null;
-    lastNotifiedOrder: Gtk.SortType;
-};
-export declare class ColumnViewNode extends SelectableListNode<Gtk.ColumnView, ColumnViewState> implements ColumnContainer {
-    static consumedPropNames: string[];
-    static matches(type: string): boolean;
-    initialize(props: Props): void;
-    private connectSorterChangedSignal;
-    private disconnectSorterChangedSignal;
-    private notifySortChange;
-    unmount(): void;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-    private applySortIndicator;
-    addColumn(columnNode: ColumnViewColumnNode): void;
-    insertColumnBefore(column: ColumnViewColumnNode, before: ColumnViewColumnNode): void;
-    removeColumn(column: ColumnViewColumnNode): void;
-}
-type ColumnViewColumnState = {
-    column: Gtk.ColumnViewColumn;
-    factory: Gtk.SignalListItemFactory;
-    factoryHandlers: ListItemFactoryHandlers | null;
-    renderCell: RenderItemFn<unknown>;
-    columnId?: string;
-    listItemCache: Map<number, ListItemInfo>;
-    sorter?: StringSorter;
-};
-export declare class ColumnViewColumnNode extends Node<never, ColumnViewColumnState> {
-    static consumedPropNames: string[];
-    static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    private columnView;
-    initialize(props: Props): void;
-    getColumn(): Gtk.ColumnViewColumn;
-    getId(): string | undefined;
-    setColumnView(columnView: ColumnViewNode | null): void;
-    unmount(): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-}
-export declare class ColumnViewItemNode extends VirtualItemNode {
-    static matches(type: string): boolean;
-}
 export {};