@gtkx/react 0.19.0 → 0.21.0

package/src/nodes/internal/construct.ts

@@ -1,90 +1,60 @@
-import { type Arg, call, type NativeHandle, registerNativeObject, setInstantiating, type Type } from "@gtkx/ffi";
-import { typeFromName } from "@gtkx/ffi/gobject";
-import { CONSTRUCT_ONLY_PROPS, CONSTRUCTOR_PROPS } from "../../generated/internal.js";
+import type { NativeClass, Type } from "@gtkx/ffi";
+import { Object as GObject, Value } from "@gtkx/ffi/gobject";
+import { CONSTRUCTION_META } from "../../generated/internal.js";
 import type { Container, ContainerClass, Props } from "../../types.js";
 
-type ConstructOnlyPropInfo = { girName: string; ffiType: Type };
+type ConstructionPropMeta = {
+    girName: string;
+    ffiType: Type;
+    constructOnly?: true;
+};
 
-/**
- * Collects construct-only property metadata by walking the class hierarchy.
- * Returns all active construct-only props (those with values set in the initial props)
- * that are NOT already handled by the designated constructor parameters.
- */
-function collectActiveConstructOnlyProps(
+function collectConstructionProps(
     containerClass: ContainerClass,
     props: Props,
 ): Array<{ girName: string; ffiType: Type; value: unknown }> {
     const result: Array<{ girName: string; ffiType: Type; value: unknown }> = [];
-    const constructorParams = new Set(CONSTRUCTOR_PROPS[containerClass.glibTypeName] ?? []);
-
-    // biome-ignore lint/suspicious/noExplicitAny: Walking static prototype chain
-    let current: any = containerClass;
-    while (current?.glibTypeName) {
-        const propsForType: Record<string, ConstructOnlyPropInfo> | undefined =
-            CONSTRUCT_ONLY_PROPS[current.glibTypeName as string];
-        if (propsForType) {
-            for (const [camelName, meta] of Object.entries(propsForType)) {
-                if (constructorParams.has(camelName)) continue;
+    const seen = new Set<string>();
+
+    // biome-ignore lint/complexity/noBannedTypes: Walking prototype chain requires Function type
+    let current: Function | null = containerClass;
+    while (current) {
+        const typeName = (current as NativeClass).glibTypeName;
+        if (!typeName) break;
+
+        const meta: Record<string, ConstructionPropMeta> | undefined = CONSTRUCTION_META[typeName];
+        if (meta) {
+            for (const [camelName, propMeta] of Object.entries(meta)) {
+                if (seen.has(camelName)) continue;
+                seen.add(camelName);
                 if (props[camelName] !== undefined) {
-                    const rawValue = props[camelName];
-                    const value =
-                        meta.ffiType.type === "gobject" &&
-                        rawValue &&
-                        typeof rawValue === "object" &&
-                        "handle" in rawValue
-                            ? (rawValue as { handle: NativeHandle }).handle
-                            : rawValue;
-                    result.push({ girName: meta.girName, ffiType: meta.ffiType, value });
+                    result.push({
+                        girName: propMeta.girName,
+                        ffiType: propMeta.ffiType,
+                        value: props[camelName],
+                    });
                 }
             }
         }
+
         current = Object.getPrototypeOf(current);
+        if (current === Object || current === Function) break;
     }
 
     return result;
 }
 
-/**
- * Creates a container (widget or controller) with construct-only properties.
- *
- * When construct-only props are present that aren't handled by the designated
- * constructor, uses `g_object_new` to set them during object construction.
- * Otherwise falls back to the normal constructor.
- */
-export function createContainerWithConstructOnly(
-    containerClass: ContainerClass,
-    props: Props,
-    normalConstructor: () => Container,
-): Container {
-    const constructOnlyArgs = collectActiveConstructOnlyProps(containerClass, props);
-
-    if (constructOnlyArgs.length === 0) {
-        return normalConstructor();
-    }
-
-    const typeName = containerClass.glibTypeName;
-    const gtype = typeFromName(typeName);
+export function createContainerWithProperties(containerClass: ContainerClass, props: Props): Container {
+    const gtype = containerClass.getGType();
+    const constructionProps = collectConstructionProps(containerClass, props);
 
-    const args: Arg[] = [{ type: { type: "int", size: 64, unsigned: true }, value: gtype, optional: false }];
+    const names: string[] = [];
+    const values: Value[] = [];
 
-    for (const { girName, ffiType, value } of constructOnlyArgs) {
-        args.push({ type: { type: "string", ownership: "borrowed" }, value: girName, optional: false });
-        args.push({ type: ffiType, value, optional: false });
+    for (const { girName, ffiType, value } of constructionProps) {
+        names.push(girName);
+        values.push(Value.newFrom(ffiType, value));
     }
 
-    args.push({ type: { type: "null" }, value: null, optional: false });
-
-    const handle = call("libgobject-2.0.so.0", "g_object_new", args, {
-        type: "gobject",
-        ownership: "full",
-    }) as NativeHandle;
-
-    setInstantiating(true);
-    // biome-ignore lint/suspicious/noExplicitAny: Dynamic instantiation with isInstantiating flag
-    const instance = new (containerClass as any)() as Container & { handle: NativeHandle };
-    setInstantiating(false);
-    instance.handle = handle;
-    registerNativeObject(instance);
-
-    return instance;
+    return GObject.newWithProperties(gtype, names, values) as unknown as Container;
 }

package/src/nodes/internal/widget.ts

@@ -1,6 +1,6 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 import { resolvePropMeta } from "../../metadata.js";
-import type { ContainerClass } from "../../types.js";
+
 import { isAddable, isAppendable, isContentWidget, isRemovable, isSingleChild } from "./predicates.js";
 
 export function detachChild(child: Gtk.Widget, container: Gtk.Widget): void {
@@ -14,6 +14,8 @@ export function detachChild(child: Gtk.Widget, container: Gtk.Widget): void {
         container.setChild(null);
     } else if (isRemovable(container)) {
         container.remove(child);
+    } else {
+        child.unparent();
     }
 }
 
@@ -27,7 +29,7 @@ export function attachChild(child: Gtk.Widget, container: Gtk.Widget): void {
     } else if (isSingleChild(container)) {
         container.setChild(child);
     } else {
-        throw new Error(`Cannot attach child to '${container.constructor.name}': container does not support children`);
+        child.setParent(container);
     }
 }
 
@@ -60,19 +62,13 @@ export function resolvePropertySetter(
     parentWidget: Gtk.Widget,
     propId: string,
 ): ((child: Gtk.Widget | null) => void) | null {
-    const propMeta = resolvePropMeta(parentWidget, propId);
+    const propName = resolvePropMeta(parentWidget, propId);
 
-    if (!propMeta) {
+    if (!propName) {
         return null;
     }
 
-    const [, setterName] = propMeta;
-    const setter = parentWidget[setterName as keyof Gtk.Widget];
-
-    if (typeof setter !== "function") {
-        const parentType = (parentWidget.constructor as ContainerClass).glibTypeName;
-        throw new Error(`Expected setter function for property '${propId}' on type '${parentType}'`);
-    }
-
-    return setter.bind(parentWidget) as (child: Gtk.Widget | null) => void;
+    return (child: Gtk.Widget | null) => {
+        (parentWidget as unknown as Record<string, unknown>)[propName] = child;
+    };
 }

package/src/nodes/list-item-node.ts

@@ -0,0 +1,53 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { Node } from "../node.js";
+import type { Container, Props } from "../types.js";
+import { isRemovable } from "./internal/predicates.js";
+import { WidgetNode } from "./widget.js";
+
+export class ListItemNode extends Node<Gtk.ListItem | Gtk.ListHeader, Props, Node, Node> {
+    public override isValidChild(_child: Node): boolean {
+        return true;
+    }
+
+    public override appendChild(child: Node): void {
+        super.appendChild(child);
+
+        if (child instanceof WidgetNode) {
+            this.detachFromGtkParent(child);
+            this.container.setChild(child.container);
+        }
+    }
+
+    public override removeChild(child: Node): void {
+        if (child instanceof WidgetNode) {
+            this.container.setChild(null);
+        }
+
+        super.removeChild(child);
+    }
+
+    public override insertBefore(child: Node, before: Node): void {
+        super.insertBefore(child, before);
+
+        if (child instanceof WidgetNode) {
+            this.detachFromGtkParent(child);
+            this.container.setChild(child.container);
+        }
+    }
+
+    private detachFromGtkParent(child: Node): void {
+        if (!(child instanceof WidgetNode)) return;
+        const currentParent = child.container.getParent();
+        if (currentParent !== null) {
+            if (isRemovable(currentParent)) {
+                currentParent.remove(child.container);
+            } else {
+                child.container.unparent();
+            }
+        }
+    }
+
+    public static override createContainer(): Container {
+        throw new Error("ListItemNode does not support container creation");
+    }
+}