@gtkx/react 0.1.11

package/dist/generated/jsx.js

@@ -0,0 +1,264 @@
+export const CONSTRUCTOR_PARAMS = {
+    AppChooserButton: [{ name: "contentType", hasDefault: false }],
+    AppChooserDialog: [
+        { name: "parent", hasDefault: true },
+        { name: "flags", hasDefault: false },
+        { name: "file", hasDefault: false },
+    ],
+    AppChooserWidget: [{ name: "contentType", hasDefault: false }],
+    ApplicationWindow: [{ name: "application", hasDefault: false }],
+    AspectFrame: [
+        { name: "xalign", hasDefault: false },
+        { name: "yalign", hasDefault: false },
+        { name: "ratio", hasDefault: false },
+        { name: "obeyChild", hasDefault: false },
+    ],
+    Box: [
+        { name: "orientation", hasDefault: false },
+        { name: "spacing", hasDefault: false },
+    ],
+    ColorChooserDialog: [
+        { name: "title", hasDefault: true },
+        { name: "parent", hasDefault: true },
+    ],
+    ColorDialogButton: [{ name: "dialog", hasDefault: true }],
+    ColumnView: [{ name: "model", hasDefault: true }],
+    DropDown: [
+        { name: "model", hasDefault: true },
+        { name: "expression", hasDefault: true },
+    ],
+    EditableLabel: [{ name: "str", hasDefault: false }],
+    Expander: [{ name: "label", hasDefault: true }],
+    FileChooserWidget: [{ name: "action", hasDefault: false }],
+    FontChooserDialog: [
+        { name: "title", hasDefault: true },
+        { name: "parent", hasDefault: true },
+    ],
+    FontDialogButton: [{ name: "dialog", hasDefault: true }],
+    Frame: [{ name: "label", hasDefault: true }],
+    GraphicsOffload: [{ name: "child", hasDefault: true }],
+    GridView: [
+        { name: "model", hasDefault: true },
+        { name: "factory", hasDefault: true },
+    ],
+    Inscription: [{ name: "text", hasDefault: true }],
+    Label: [{ name: "str", hasDefault: true }],
+    LinkButton: [{ name: "uri", hasDefault: false }],
+    ListView: [
+        { name: "model", hasDefault: true },
+        { name: "factory", hasDefault: true },
+    ],
+    LockButton: [{ name: "permission", hasDefault: true }],
+    MediaControls: [{ name: "stream", hasDefault: true }],
+    PageSetupUnixDialog: [
+        { name: "title", hasDefault: true },
+        { name: "parent", hasDefault: true },
+    ],
+    Paned: [{ name: "orientation", hasDefault: false }],
+    PrintUnixDialog: [
+        { name: "title", hasDefault: true },
+        { name: "parent", hasDefault: true },
+    ],
+    Scale: [
+        { name: "orientation", hasDefault: false },
+        { name: "adjustment", hasDefault: true },
+    ],
+    ScaleButton: [
+        { name: "min", hasDefault: false },
+        { name: "max", hasDefault: false },
+        { name: "step", hasDefault: false },
+        { name: "icons", hasDefault: true },
+    ],
+    Scrollbar: [
+        { name: "orientation", hasDefault: false },
+        { name: "adjustment", hasDefault: true },
+    ],
+    Separator: [{ name: "orientation", hasDefault: false }],
+    ShortcutLabel: [{ name: "accelerator", hasDefault: false }],
+    SpinButton: [
+        { name: "adjustment", hasDefault: true },
+        { name: "climbRate", hasDefault: false },
+        { name: "digits", hasDefault: false },
+    ],
+    Viewport: [
+        { name: "hadjustment", hasDefault: true },
+        { name: "vadjustment", hasDefault: true },
+    ],
+    WindowControls: [{ name: "side", hasDefault: false }],
+};
+export const Widget = "Widget";
+export const Window = {
+    Root: "Window.Root",
+    Child: "Window.Child",
+    DefaultWidget: "Window.DefaultWidget",
+    FocusWidget: "Window.FocusWidget",
+    Titlebar: "Window.Titlebar",
+    TransientFor: "Window.TransientFor",
+};
+export const AboutDialog = "AboutDialog";
+export const ActionBar = "ActionBar";
+export const AppChooserButton = "AppChooserButton";
+export const AppChooserDialog = "AppChooserDialog";
+export const AppChooserWidget = "AppChooserWidget";
+export const ApplicationWindow = "ApplicationWindow";
+export const AspectFrame = "AspectFrame";
+export const Assistant = "Assistant";
+export const Box = "Box";
+export const Button = "Button";
+export const Calendar = "Calendar";
+export const CellView = "CellView";
+export const CenterBox = {
+    Root: "CenterBox.Root",
+    CenterWidget: "CenterBox.CenterWidget",
+    EndWidget: "CenterBox.EndWidget",
+    StartWidget: "CenterBox.StartWidget",
+};
+export const CheckButton = {
+    Root: "CheckButton.Root",
+    Child: "CheckButton.Child",
+    Group: "CheckButton.Group",
+};
+export const ColorButton = "ColorButton";
+export const ColorChooserDialog = "ColorChooserDialog";
+export const ColorChooserWidget = "ColorChooserWidget";
+export const ColorDialogButton = "ColorDialogButton";
+export const ColumnView = {
+    Root: "ColumnView.Root",
+    Item: "ColumnView.Item",
+};
+export const ComboBox = "ComboBox";
+export const ComboBoxText = "ComboBoxText";
+export const Dialog = "Dialog";
+export const DragIcon = "DragIcon";
+export const DrawingArea = "DrawingArea";
+export const DropDown = {
+    Root: "DropDown.Root",
+    Item: "DropDown.Item",
+};
+export const EditableLabel = "EditableLabel";
+export const EmojiChooser = "EmojiChooser";
+export const Entry = "Entry";
+export const Expander = {
+    Root: "Expander.Root",
+    Child: "Expander.Child",
+    LabelWidget: "Expander.LabelWidget",
+};
+export const FileChooserDialog = "FileChooserDialog";
+export const FileChooserWidget = "FileChooserWidget";
+export const Fixed = "Fixed";
+export const FlowBox = "FlowBox";
+export const FlowBoxChild = "FlowBoxChild";
+export const FontButton = "FontButton";
+export const FontChooserDialog = "FontChooserDialog";
+export const FontChooserWidget = "FontChooserWidget";
+export const FontDialogButton = "FontDialogButton";
+export const Frame = {
+    Root: "Frame.Root",
+    Child: "Frame.Child",
+    LabelWidget: "Frame.LabelWidget",
+};
+export const GLArea = "GLArea";
+export const GraphicsOffload = "GraphicsOffload";
+export const Grid = {
+    Root: "Grid.Root",
+    Child: "Grid.Child",
+};
+export const GridView = {
+    Root: "GridView.Root",
+    Item: "GridView.Item",
+};
+export const HeaderBar = {
+    Root: "HeaderBar.Root",
+    TitleWidget: "HeaderBar.TitleWidget",
+};
+export const IconView = "IconView";
+export const Image = "Image";
+export const InfoBar = "InfoBar";
+export const Inscription = "Inscription";
+export const Label = {
+    Root: "Label.Root",
+    MnemonicWidget: "Label.MnemonicWidget",
+};
+export const LevelBar = "LevelBar";
+export const LinkButton = "LinkButton";
+export const ListBase = "ListBase";
+export const ListBox = "ListBox";
+export const ListBoxRow = "ListBoxRow";
+export const ListView = {
+    Root: "ListView.Root",
+    Item: "ListView.Item",
+};
+export const LockButton = "LockButton";
+export const MediaControls = "MediaControls";
+export const MenuButton = {
+    Root: "MenuButton.Root",
+    Child: "MenuButton.Child",
+    Popover: "MenuButton.Popover",
+};
+export const MessageDialog = "MessageDialog";
+export const Notebook = "Notebook";
+export const Overlay = "Overlay";
+export const PageSetupUnixDialog = "PageSetupUnixDialog";
+export const Paned = {
+    Root: "Paned.Root",
+    EndChild: "Paned.EndChild",
+    StartChild: "Paned.StartChild",
+};
+export const PasswordEntry = "PasswordEntry";
+export const Picture = "Picture";
+export const Popover = {
+    Root: "Popover.Root",
+    Child: "Popover.Child",
+    DefaultWidget: "Popover.DefaultWidget",
+};
+export const PopoverMenu = "PopoverMenu";
+export const PopoverMenuBar = "PopoverMenuBar";
+export const PrintUnixDialog = "PrintUnixDialog";
+export const ProgressBar = "ProgressBar";
+export const Range = "Range";
+export const Revealer = "Revealer";
+export const Scale = "Scale";
+export const ScaleButton = "ScaleButton";
+export const Scrollbar = "Scrollbar";
+export const ScrolledWindow = "ScrolledWindow";
+export const SearchBar = {
+    Root: "SearchBar.Root",
+    Child: "SearchBar.Child",
+    KeyCaptureWidget: "SearchBar.KeyCaptureWidget",
+};
+export const SearchEntry = "SearchEntry";
+export const Separator = "Separator";
+export const ShortcutLabel = "ShortcutLabel";
+export const ShortcutsGroup = "ShortcutsGroup";
+export const ShortcutsSection = "ShortcutsSection";
+export const ShortcutsShortcut = "ShortcutsShortcut";
+export const ShortcutsWindow = "ShortcutsWindow";
+export const SpinButton = "SpinButton";
+export const Spinner = "Spinner";
+export const Stack = {
+    Root: "Stack.Root",
+    VisibleChild: "Stack.VisibleChild",
+};
+export const StackSidebar = {
+    Root: "StackSidebar.Root",
+    Stack: "StackSidebar.Stack",
+};
+export const StackSwitcher = {
+    Root: "StackSwitcher.Root",
+    Stack: "StackSwitcher.Stack",
+};
+export const Statusbar = "Statusbar";
+export const Switch = "Switch";
+export const Text = "Text";
+export const TextView = "TextView";
+export const ToggleButton = {
+    Root: "ToggleButton.Root",
+    Group: "ToggleButton.Group",
+};
+export const TreeExpander = "TreeExpander";
+export const TreeView = "TreeView";
+export const Video = "Video";
+export const Viewport = "Viewport";
+export const VolumeButton = "VolumeButton";
+export const WindowControls = "WindowControls";
+export const WindowHandle = "WindowHandle";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createRef } from "@gtkx/ffi";
+export * from "./generated/jsx.js";
+export { createPortal } from "./portal.js";
+export { render } from "./render.js";
+export declare const quit: () => boolean;

package/dist/index.js

@@ -0,0 +1,14 @@
+export { createRef } from "@gtkx/ffi";
+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 { container } from "./render.js";
+export const quit = () => {
+    reconciler.updateContainer(null, container, null, () => {
+        disposeAllInstances();
+        stop();
+    });
+    return false;
+};

package/dist/node.d.ts

@@ -0,0 +1,13 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "./factory.js";
+export interface Node<W extends Gtk.Widget = Gtk.Widget> {
+    getWidget?(): W;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+    mount(): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+    dispose?(): void;
+}

package/dist/node.js

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

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

@@ -0,0 +1,27 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+interface ActionBarWidget extends Gtk.Widget {
+    packStart(child: unknown): void;
+    remove(child: unknown): void;
+    setRevealed(revealed: boolean): void;
+}
+export declare class ActionBarNode implements Node<ActionBarWidget> {
+    static needsWidget: boolean;
+    static matches(type: string, widget: Gtk.Widget | null): widget is ActionBarWidget;
+    private widget;
+    private signalHandlers;
+    constructor(_type: string, widget: Gtk.Widget, _props: Props);
+    getWidget(): ActionBarWidget;
+    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/action-bar.js

@@ -0,0 +1,88 @@
+import { appendChild, disconnectSignalHandlers, isConnectable, removeChild } from "../widget-capabilities.js";
+const isActionBarWidget = (widget) => "packStart" in widget &&
+    typeof widget.packStart === "function" &&
+    "remove" in widget &&
+    typeof widget.remove === "function";
+export class ActionBarNode {
+    static needsWidget = true;
+    static matches(type, widget) {
+        if (type !== "ActionBar" && type !== "ActionBar.Root")
+            return false;
+        return widget !== null && isActionBarWidget(widget);
+    }
+    widget;
+    signalHandlers = new Map();
+    constructor(_type, widget, _props) {
+        if (!isActionBarWidget(widget)) {
+            throw new Error("ActionBarNode requires an ActionBar 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.packStart(childWidget.ptr);
+    }
+    detachChild(childWidget) {
+        this.widget.remove(childWidget.ptr);
+    }
+    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/dialog.d.ts

@@ -0,0 +1,19 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+export declare class DialogNode implements Node {
+    static needsWidget: boolean;
+    static matches(type: string, widget: Gtk.Widget | null): widget is Gtk.Widget;
+    private widget;
+    private signalHandlers;
+    constructor(_type: string, widget: Gtk.Widget, _props: Props);
+    getWidget(): Gtk.Widget;
+    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;
+    dispose(): void;
+}

package/dist/nodes/dialog.js

@@ -0,0 +1,87 @@
+import * as GObject from "@gtkx/ffi/gobject";
+import { getActiveWindow } from "../reconciler.js";
+import { disconnectSignalHandlers, isConnectable } from "../widget-capabilities.js";
+const DIALOG_TYPES = new Set([
+    "AboutDialog",
+    "Dialog",
+    "AppChooserDialog",
+    "ColorChooserDialog",
+    "FontChooserDialog",
+    "FileChooserDialog",
+    "MessageDialog",
+    "PageSetupUnixDialog",
+    "PrintUnixDialog",
+    "Assistant",
+    "ShortcutsWindow",
+]);
+const isDialog = (widget) => {
+    return "setTransientFor" in widget && "present" in widget;
+};
+export class DialogNode {
+    static needsWidget = true;
+    static matches(type, widget) {
+        const normalizedType = type.endsWith(".Root") ? type.slice(0, -5) : type;
+        return widget !== null && DIALOG_TYPES.has(normalizedType);
+    }
+    widget;
+    signalHandlers = new Map();
+    constructor(_type, widget, _props) {
+        this.widget = widget;
+    }
+    getWidget() {
+        return this.widget;
+    }
+    appendChild(_child) { }
+    removeChild(_child) { }
+    insertBefore(_child, _before) { }
+    attachToParent(_parent) { }
+    detachFromParent(_parent) { }
+    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) {
+                    GObject.signalHandlerDisconnect(this.widget, oldHandlerId);
+                    this.signalHandlers.delete(eventName);
+                }
+                if (typeof newValue === "function" && isConnectable(this.widget)) {
+                    const handlerId = this.widget.connect(eventName, newValue);
+                    this.signalHandlers.set(eventName, handlerId);
+                }
+                continue;
+            }
+            if (newValue === undefined)
+                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() {
+        if (isDialog(this.widget)) {
+            const activeWindow = getActiveWindow();
+            if (activeWindow) {
+                this.widget.setTransientFor(activeWindow);
+            }
+            this.widget.present();
+        }
+    }
+    dispose() {
+        disconnectSignalHandlers(this.widget, this.signalHandlers);
+    }
+}

package/dist/nodes/dropdown.d.ts

@@ -0,0 +1,41 @@
+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;
+    private labelFn;
+    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;
+    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;
+    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 {};