@gjsify/adwaita-core 0.64.12 → 0.64.13

package/lib/types/split-button.d.ts

@@ -28,7 +28,11 @@ export interface SplitButtonChange {
     mode: SplitButtonContentMode;
     /** The label, or `null` unless {@link mode} is `'label'`. */
     label: string | null;
-    /** The icon name, or `null` unless {@link mode} is `'icon'`. */
+    /**
+     * The icon name as `get_icon_name` reads it back: `null` unless {@link mode} is
+     * `'icon'`, and `null` as well for an icon name set to `''`
+     * ({@link gtkButtonIconNameReadback}).
+     */
     iconName: string | null;
     /** The child widget — the app's in `'child'` mode, an opaque internal node in `'label'`/`'icon'` mode. */
     child: object | null;
@@ -135,6 +139,11 @@ export declare class SplitButtonState {
     /** Subscribe to state changes. Returns an unsubscribe function. */
     subscribe(listener: SplitButtonListener): () => void;
     private _emit;
+    /**
+     * The `notify::*` sequence a content mutation owes, per {@link CONTENT_NOTIFY_ORDER}.
+     * Reads the PRE-state, so every caller must build its list before mutating.
+     */
+    private _contentNotify;
     /** Which content slot is filled. */
     get mode(): SplitButtonContentMode;
     /** The label, or `null` unless {@link mode} is `'label'`. */
@@ -145,11 +154,19 @@ export declare class SplitButtonState {
      * C, clearing it is a side effect of setting another slot.
      */
     setLabel(label: string): boolean;
-    /** The icon name, or `null` unless {@link mode} is `'icon'`. */
+    /**
+     * The icon name as `adw_split_button_get_icon_name` reads it back — `null` unless
+     * {@link mode} is `'icon'`, and `null` as well for an icon name set to `''`, which
+     * leaves GtkButton's internal image EMPTY ({@link gtkButtonIconNameReadback}).
+     */
     get iconName(): string | null;
     /**
      * Set the icon name, clearing `label` and `child`. A non-string is rejected —
      * `g_return_if_fail (icon_name != NULL)`.
+     *
+     * The guard is C's `g_strcmp0 (icon_name, get_icon_name (self))`: against the
+     * READBACK, so `''` is never equal to the `null` it reads back as and every
+     * `setIconName('')` is a change that notifies afresh.
      */
     setIconName(iconName: string): boolean;
     /**
@@ -190,15 +207,20 @@ export declare class SplitButtonState {
      * from a renderer's point of view. A model that is non-empty but draws nothing — one
      * empty section — is NOT collapsed: it has a node, so it is a menu, which is the
      * answer GTK gives for the same `GMenu`.
+     *
+     * Notifies both properties per {@link DROPDOWN_NOTIFY_ORDER}; the guard is on the
+     * menu model ALONE, so clearing it on a popover-only button emits nothing.
      */
     setMenuModel(input: AdwMenuInput | null | undefined): boolean;
     /** The popover: the one the app set, or the model-derived stand-in, or `null`. */
     get popover(): object | null;
     /**
-     * Set the popover, dissociating any menu model. The cleared property is notified before
-     * the set one, the order `set_label()`/`set_icon_name`/`set_child` use throughout this
-     * widget; GtkMenuButton's own internal ordering is not observable from the upstream
-     * suite, which only counts per-property notifications.
+     * Set (or clear, with `null`) the popover, dissociating any menu model. Both properties
+     * are notified per {@link DROPDOWN_NOTIFY_ORDER}, UNCONDITIONALLY — setting a popover on
+     * a split button that never had a menu model still emits `notify::menu-model`.
+     *
+     * The guard is pointer equality on the popover ALONE, so handing back the
+     * model-derived popover is a no-op that leaves the menu model in place.
      */
     setPopover(popover: object | null | undefined): boolean;
     /**

package/lib/types/widget-members.d.ts

@@ -8,17 +8,52 @@ interface WidgetNode extends PointNode {
     removeAttribute(name: string): void;
     hasAttribute(name: string): boolean;
     toggleAttribute(name: string, force?: boolean): boolean;
-    readonly firstElementChild: unknown;
-    readonly lastElementChild: unknown;
-    readonly nextElementSibling: unknown;
-    readonly previousElementSibling: unknown;
-    readonly parentElement: unknown;
+    readonly localName: string;
+    readonly firstElementChild: LinkedNode | null;
+    readonly lastElementChild: LinkedNode | null;
+    readonly nextElementSibling: LinkedNode | null;
+    readonly previousElementSibling: LinkedNode | null;
+    readonly parentElement: LinkedNode | null;
     readonly classList: {
         add(name: string): void;
         remove(name: string): void;
         contains(name: string): boolean;
     };
 }
+/**
+ * What the tree walkers need of a node they STEP OVER: its name, and the link to the next
+ * candidate. A `<span>` a label built answers both and is no `WidgetNode` — the whole point.
+ */
+interface LinkedNode {
+    readonly localName: string;
+    readonly firstElementChild: LinkedNode | null;
+    readonly lastElementChild: LinkedNode | null;
+    readonly nextElementSibling: LinkedNode | null;
+    readonly previousElementSibling: LinkedNode | null;
+    readonly parentElement: LinkedNode | null;
+}
+/**
+ * Is this element a WIDGET, or a piece of a widget's own insides?
+ *
+ * `gtk_widget_get_first_child` walks the WIDGET tree — every node it hands back is a
+ * `GtkWidget`, including the template children of a composite one. A DOM port has a second
+ * kind of child in the same `children` list: the `<span>` a label's markup renderer builds,
+ * the `<div>` a row lays its slots out in. Those are not widgets in any renderer, and a
+ * caller that got one back found `instanceof Gtk.Label` false and, one step further, no
+ * `get_first_child` on it at all — a `TypeError` thrown in the consumer's walk, far from
+ * the port that produced the node. (Measured in Learn6502: a depth-first walk over the
+ * rendered tutorial hit the spans inside a label and died.)
+ *
+ * The test is the one the DOM itself guarantees: a custom element name MUST contain a
+ * hyphen and a built-in one may not, so `localName.includes('-')` separates the two kinds
+ * exactly. `compute-expand.ts` reads the same signal for the same reason.
+ *
+ * Reference: GTK gtk/gtkwidget.c (gtk_widget_get_first_child — `priv->first_child`, a
+ * GtkWidget), WHATWG HTML § custom element name (the hyphen requirement).
+ */
+export declare function isWidgetNode(node: {
+    readonly localName: string;
+} | null | undefined): boolean;
 /**
  * Mirrors the held direction onto the `dir` attribute. A custom element may not take an attribute
  * while `createElement` constructs it, and a widget's constructor is where GTK code pins its

package/lib/types/widget-members.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-core",
-    "version": "0.64.12",
+    "version": "0.64.13",
     "description": "Headless Adwaita widget behavior (breakpoint condition grammar + apply/unapply state machine, color-scheme observable, avatar derivation) shared by the web and NativeScript Adwaita renderers — pure TS, no platform imports",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -67,9 +67,9 @@
         "headless"
     ],
     "devDependencies": {
-        "@gjsify/cli": "^0.64.12",
+        "@gjsify/cli": "^0.64.13",
         "@gjsify/node-gi": "file:../../../packages/node-gi/node-gi",
-        "@gjsify/unit": "^0.64.12",
+        "@gjsify/unit": "^0.64.13",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },