@gjsify/adwaita-web 0.64.12 → 0.64.13

package/src/widget-element.ts

@@ -16,10 +16,25 @@
 // Reference: GTK gtk/gtkwidget.c (gtk_widget_set_visible, gtk_widget_set_tooltip_text)
 // Copyright (c) GNOME contributors (GTK). LGPLv2.1+.
 
+import { isWidgetNode } from '@gjsify/adwaita-core';
+
 import { WIDGET_VISIBLE_GETTERS, installElementApi, markLazyElementApi, notifyElement } from './gobject-elements.js';
 import { dispatchedSignalsOf, type DispatchedSignals } from './signals.js';
 import { isMapped } from './widget-mapping.js';
 
+/** Element links, walked until one lands on a widget: `isWidgetNode` says which those are. */
+type ElementLink =
+    | 'firstElementChild'
+    | 'lastElementChild'
+    | 'nextElementSibling'
+    | 'previousElementSibling'
+    | 'parentElement';
+
+function widgetChild(from: Element, first: ElementLink, next: ElementLink): Element | null {
+    for (let at = from[first]; at !== null; at = at[next]) if (isWidgetNode(at)) return at;
+    return null;
+}
+
 export class WidgetElement extends HTMLElement {
     /** `Gtk.Widget::map` / `::unmap`, which every subclass inherits (`dispatchedSignalsOf`). */
     static readonly signals: DispatchedSignals = { map: 'map', unmap: 'unmap' };
@@ -41,25 +56,31 @@ export class WidgetElement extends HTMLElement {
     set_visible(visible: boolean): void {
         this.visible = visible;
     }
-    /** `gtk_widget_get_first_child`: the first child element, `null` for a leaf. */
+    /**
+     * `gtk_widget_get_first_child`: the first child WIDGET, `null` for a leaf.
+     *
+     * The five walkers skip the elements a port builds for its own insides — `isWidgetNode`
+     * in `@gjsify/adwaita-core` carries the rule and the incident behind it, and the
+     * registered-class copy in `widgetTreeMembers()` answers from the same function.
+     */
     get_first_child(): Element | null {
-        return this.firstElementChild;
+        return widgetChild(this, 'firstElementChild', 'nextElementSibling');
     }
     /** `gtk_widget_get_last_child`. */
     get_last_child(): Element | null {
-        return this.lastElementChild;
+        return widgetChild(this, 'lastElementChild', 'previousElementSibling');
     }
     /** `gtk_widget_get_next_sibling`. */
     get_next_sibling(): Element | null {
-        return this.nextElementSibling;
+        return widgetChild(this, 'nextElementSibling', 'nextElementSibling');
     }
     /** `gtk_widget_get_prev_sibling`. */
     get_prev_sibling(): Element | null {
-        return this.previousElementSibling;
+        return widgetChild(this, 'previousElementSibling', 'previousElementSibling');
     }
-    /** `gtk_widget_get_parent`. */
+    /** `gtk_widget_get_parent`: the nearest ancestor that is a widget, not a port's own wrapper. */
     get_parent(): Element | null {
-        return this.parentElement;
+        return widgetChild(this, 'parentElement', 'parentElement');
     }
     /** `gtk_widget_get_width`: the layout box in CSS px; 0 until the widget is rendered. */
     get_width(): number {

package/src/widget-members.spec.ts

@@ -60,10 +60,10 @@ export const WidgetMembersTest = async () => {
             expect(() => widget.set_direction(7)).toThrow();
         });
 
-        await it('walks the element tree with the GTK link names', () => {
+        await it('walks the widget tree with the GTK link names', () => {
             const parent = make('WidgetMembersParent');
-            const a = document.createElement('div');
-            const b = document.createElement('div');
+            const a = new Gtk.Label() as unknown as WidgetLike;
+            const b = new Gtk.Label() as unknown as WidgetLike;
             parent.append(a, b);
             expect(parent.get_first_child()).toBe(a);
             expect(parent.get_last_child()).toBe(b);
@@ -73,6 +73,45 @@ export const WidgetMembersTest = async () => {
             expect(parent.get_parent()).toBe(null);
         });
 
+        await it("steps over the plain elements a port builds for a widget's insides", () => {
+            // `gtk_widget_get_first_child` hands back a GtkWidget, always. In a DOM port the
+            // same `children` list also holds what the port made for itself — the `<span>` a
+            // label's markup renderer writes, the `<div>` a row lays its slots out in — and a
+            // caller walking the tree would get one of those and find no `get_first_child` on
+            // it at all. The custom-element hyphen separates the two kinds (`isWidgetNode`).
+            const parent = make('WidgetMembersInsides');
+            const a = new Gtk.Label() as unknown as WidgetLike;
+            const b = new Gtk.Label() as unknown as WidgetLike;
+            parent.append(
+                document.createElement('span'),
+                a,
+                document.createElement('div'),
+                b,
+                document.createElement('span'),
+            );
+            expect(parent.get_first_child()).toBe(a);
+            expect(parent.get_last_child()).toBe(b);
+            expect(a.get_next_sibling()).toBe(b);
+            expect(b.get_prev_sibling()).toBe(a);
+            expect(b.get_next_sibling()).toBe(null);
+        });
+
+        await it('a widget holding only its own markup is a LEAF', () => {
+            const label = make('WidgetMembersLeaf');
+            label.append(document.createElement('span'), document.createElement('span'));
+            expect(label.get_first_child()).toBe(null);
+            expect(label.get_last_child()).toBe(null);
+        });
+
+        await it('get_parent reports the nearest ancestor that is a widget', () => {
+            const box = new Gtk.Box() as unknown as WidgetLike;
+            const wrapper = document.createElement('div');
+            const label = new Gtk.Label() as unknown as WidgetLike;
+            box.append(wrapper);
+            wrapper.append(label);
+            expect(label.get_parent()).toBe(box);
+        });
+
         await it('walks the element tree of a built-in widget with the GTK link names', () => {
             const box = new Gtk.Box() as unknown as WidgetLike;
             const a = new Gtk.Label() as unknown as WidgetLike;