@gtkx/react 1.4.0 → 1.5.0

package/src/adw/element-behaviors.ts

@@ -2,8 +2,6 @@ import type * as Gtk from "@gtkx/gi/gtk";
 import * as Adw from "@gtkx/gi/adw";
 import type { AlertDialogResponse } from "./prop-types.js";
 import {
-    addRemoveSlot,
-    adoptedChildrenSlot,
     applicationCreator,
     boxSlot,
     childMatcher,
@@ -12,6 +10,8 @@ import {
     deferred,
     indexedSlot,
     list,
+    methodSlot,
+    setterSlot,
     slot,
 } from "../reconciler/behaviors.js";
 import { type ElementBehavior, type ElementConfig, forTypes, registerElements } from "../reconciler/registry.js";
@@ -36,56 +36,18 @@ type PrefixSuffixRow = Adw.ActionRow | Adw.EntryRow | Adw.ExpanderRow;
 const SLOT_SUFFIX = "Slot";
 const childSetter = childSetterSlot<AdwChildSetter>();
 const contentSetter = contentSetterSlot<AdwContentSetter>();
-
-const breakpoints = slot<BreakpointHost, Adw.Breakpoint>("breakpoints", "AdwBreakpoint", {
-    attach: (host, breakpoint) => {
-        host.addBreakpoint(breakpoint);
-    },
-});
+const breakpoints = methodSlot<BreakpointHost, Adw.Breakpoint>("breakpoints", "AdwBreakpoint", "addBreakpoint");
 
 const prefixSuffix = [
-    addRemoveSlot<Gtk.Widget, PrefixSuffixRow>(
-        "prefix",
-        "GtkWidget",
-        (row, child) => {
-            row.addPrefix(child);
-        },
-        (row, child) => {
-            row.remove(child);
-        },
-    ),
-    addRemoveSlot<Gtk.Widget, PrefixSuffixRow>(
-        "suffix",
-        "GtkWidget",
-        (row, child) => {
-            row.addSuffix(child);
-        },
-        (row, child) => {
-            row.remove(child);
-        },
-    ),
+    methodSlot<PrefixSuffixRow, Gtk.Widget>("prefix", "GtkWidget", "addPrefix", "remove"),
+    methodSlot<PrefixSuffixRow, Gtk.Widget>("suffix", "GtkWidget", "addSuffix", "remove"),
 ];
 
-const preferencesDialogChildren = addRemoveSlot<Adw.PreferencesPage, Adw.PreferencesDialog>(
-    "children",
-    "AdwPreferencesPage",
-    (dialog, page) => {
-        dialog.add(page);
-    },
-    (dialog, page) => {
-        dialog.remove(page);
-    },
+const preferencesDialogChildren = methodSlot<Adw.PreferencesDialog, Adw.PreferencesPage>(
+    "children", "AdwPreferencesPage", "add", "remove",
 );
 
-const alertDialogExtraChild = slot<Adw.AlertDialog, Gtk.Widget>("children", "GtkWidget", {
-    attach: (dialog, child) => {
-        dialog.setExtraChild(child);
-    },
-    detach: (dialog) => {
-        dialog.setExtraChild(null);
-    },
-});
-
+const alertDialogExtraChild = setterSlot<Adw.AlertDialog, Gtk.Widget>("children", "GtkWidget", "setExtraChild");
 const sidebarSections = indexedSlot<Adw.Sidebar, Adw.SidebarSection>("children", "AdwSidebarSection");
 const sidebarItems = indexedSlot<Adw.SidebarSection, Adw.SidebarItem>("children", "AdwSidebarItem");
 const isWidget = childMatcher("GtkWidget");
@@ -151,14 +113,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     },
     AdwClampScrollable: {
         behaviors: [
-            slot<Adw.ClampScrollable, Gtk.Scrollable & Gtk.Widget>("children", "GtkScrollable", {
-                attach: (clamp, child) => {
-                    clamp.setChild(child);
-                },
-                detach: (clamp) => {
-                    clamp.setChild(null);
-                },
-            }),
+            setterSlot<Adw.ClampScrollable, Gtk.Scrollable & Gtk.Widget>("children", "GtkScrollable", "setChild"),
         ],
     },
     ...forTypes(CHILD_SETTER_TYPES, {
@@ -179,15 +134,8 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     AdwBreakpointBin: {
         behaviors: [
             childSetter,
-            addRemoveSlot<Adw.Breakpoint, Adw.BreakpointBin>(
-                "breakpoints",
-                "AdwBreakpoint",
-                (bin, breakpoint) => {
-                    bin.addBreakpoint(breakpoint);
-                },
-                (bin, breakpoint) => {
-                    bin.removeBreakpoint(breakpoint);
-                },
+            methodSlot<Adw.BreakpointBin, Adw.Breakpoint>(
+                "breakpoints", "AdwBreakpoint", "addBreakpoint", "removeBreakpoint",
             ),
         ],
     },
@@ -200,16 +148,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     AdwExpanderRow: {
         behaviors: [
             ...prefixSuffix,
-            addRemoveSlot<Gtk.Widget, Adw.ExpanderRow>(
-                "rows",
-                "GtkWidget",
-                (row, child) => {
-                    row.addRow(child);
-                },
-                (row, child) => {
-                    row.remove(child);
-                },
-            ),
+            methodSlot<Adw.ExpanderRow, Gtk.Widget>("rows", "GtkWidget", "addRow", "remove"),
         ],
     },
     AdwNavigationSplitView: {
@@ -249,18 +188,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
         behaviors: [preferencesDialogChildren],
     },
     AdwPreferencesGroup: {
-        behaviors: [
-            addRemoveSlot<Gtk.Widget, Adw.PreferencesGroup>(
-                "children",
-                "GtkWidget",
-                (group, child) => {
-                    group.add(child);
-                },
-                (group, child) => {
-                    group.remove(child);
-                },
-            ),
-        ],
+        behaviors: [methodSlot<Adw.PreferencesGroup, Gtk.Widget>("children", "GtkWidget", "add", "remove")],
     },
     AdwTabView: {
         behaviors: [
@@ -282,105 +210,37 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     },
     AdwNavigationView: {
         behaviors: [
-            addRemoveSlot<Adw.NavigationPage, Adw.NavigationView>(
-                "children",
-                "AdwNavigationPage",
-                (view, page) => {
-                    view.add(page);
-                },
-                (view, page) => {
-                    view.remove(page);
-                },
-            ),
+            methodSlot<Adw.NavigationView, Adw.NavigationPage>("children", "AdwNavigationPage", "add", "remove"),
         ],
     },
     AdwViewStack: {
         behaviors: [
-            adoptedChildrenSlot<Adw.ViewStack, Gtk.Widget>(
-                "GtkWidget",
-                (stack, child) => stack.add(child),
-                (stack, child) => {
-                    stack.remove(child);
-                },
-            ),
+            methodSlot<Adw.ViewStack, Gtk.Widget>("children", "GtkWidget", "add", "remove"),
             deferred<Adw.ViewStack, string>("visibleChildName", (stack, name) => stack.getChildByName(name) !== null),
         ],
     },
     AdwToolbarView: {
         behaviors: [
             contentSetterSlot<Adw.ToolbarView>(),
-            addRemoveSlot<Gtk.Widget, Adw.ToolbarView>(
-                "topBar",
-                "GtkWidget",
-                (view, child) => {
-                    view.addTopBar(child);
-                },
-                (view, child) => {
-                    view.remove(child);
-                },
-            ),
-            addRemoveSlot<Gtk.Widget, Adw.ToolbarView>(
-                "bottomBar",
-                "GtkWidget",
-                (view, child) => {
-                    view.addBottomBar(child);
-                },
-                (view, child) => {
-                    view.remove(child);
-                },
-            ),
+            methodSlot<Adw.ToolbarView, Gtk.Widget>("topBar", "GtkWidget", "addTopBar", "remove"),
+            methodSlot<Adw.ToolbarView, Gtk.Widget>("bottomBar", "GtkWidget", "addBottomBar", "remove"),
         ],
     },
     AdwHeaderBar: {
         behaviors: [
-            slot<Adw.HeaderBar, Gtk.Widget>("start", "GtkWidget", {
-                attach: (bar, child) => {
-                    bar.packStart(child);
-                },
-                detach: (bar, child) => {
-                    bar.remove(child);
-                },
-            }),
-            slot<Adw.HeaderBar, Gtk.Widget>("end", "GtkWidget", {
-                attach: (bar, child) => {
-                    bar.packEnd(child);
-                },
-                detach: (bar, child) => {
-                    bar.remove(child);
-                },
-            }),
+            methodSlot<Adw.HeaderBar, Gtk.Widget>("start", "GtkWidget", "packStart", "remove"),
+            methodSlot<Adw.HeaderBar, Gtk.Widget>("end", "GtkWidget", "packEnd", "remove"),
         ],
     },
     AdwShortcutsDialog: {
-        behaviors: [
-            slot<Adw.ShortcutsDialog, Adw.ShortcutsSection>("children", "AdwShortcutsSection", {
-                attach: (dialog, section) => {
-                    dialog.add(section);
-                },
-            }),
-        ],
+        behaviors: [methodSlot<Adw.ShortcutsDialog, Adw.ShortcutsSection>("children", "AdwShortcutsSection", "add")],
     },
     AdwShortcutsSection: {
-        behaviors: [
-            slot<Adw.ShortcutsSection, Adw.ShortcutsItem>("children", "AdwShortcutsItem", {
-                attach: (section, item) => {
-                    section.add(item);
-                },
-            }),
-        ],
+        behaviors: [methodSlot<Adw.ShortcutsSection, Adw.ShortcutsItem>("children", "AdwShortcutsItem", "add")],
     },
     AdwToggleGroup: {
         behaviors: [
-            addRemoveSlot<Adw.Toggle, Adw.ToggleGroup>(
-                "children",
-                "AdwToggle",
-                (group, toggle) => {
-                    group.add(toggle);
-                },
-                (group, toggle) => {
-                    group.remove(toggle);
-                },
-            ),
+            methodSlot<Adw.ToggleGroup, Adw.Toggle>("children", "AdwToggle", "add", "remove"),
             deferred<Adw.ToggleGroup, string>("activeName", (group, name) => group.getToggleByName(name) !== null),
             deferred("active"),
         ],

package/src/element-behaviors.ts

@@ -14,14 +14,15 @@ import type {
 } from "./prop-types.js";
 import { BUILTIN_ELEMENTS, SINGLE_CHILD_TYPES } from "./element-config.js";
 import {
-    addRemoveSlot,
-    adoptedChildrenSlot,
     applicationCreator,
     boxSlot,
     childSetterSlot,
     controlledText,
     deferred,
+    deferredWith,
     list,
+    methodSlot,
+    setterSlot,
     slot,
     value,
     wrappingIndexedSlot,
@@ -36,8 +37,6 @@ import {
 import { applyWrite } from "./reconciler/signals.js";
 import { applyStyle, CSS_CLASSES_PROP, styleClass } from "./reconciler/style.js";
 
-type SelectedIndexState = { desired: number | undefined; isScheduled: boolean; disconnect: (() => void) | null };
-
 const SELECTED_INDEX_PROP = "selectedIndex";
 const SELECTION_SIGNAL = "selected-rows-changed";
 const NO_SELECTION = -1;
@@ -48,26 +47,8 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     }),
     ...forTypes(["GtkHeaderBar", "GtkActionBar"], {
         behaviors: [
-            addRemoveSlot<Gtk.Widget, Gtk.HeaderBar | Gtk.ActionBar>(
-                "start",
-                "GtkWidget",
-                (bar, child) => {
-                    bar.packStart(child);
-                },
-                (bar, child) => {
-                    bar.remove(child);
-                },
-            ),
-            addRemoveSlot<Gtk.Widget, Gtk.HeaderBar | Gtk.ActionBar>(
-                "end",
-                "GtkWidget",
-                (bar, child) => {
-                    bar.packEnd(child);
-                },
-                (bar, child) => {
-                    bar.remove(child);
-                },
-            ),
+            methodSlot<Gtk.HeaderBar | Gtk.ActionBar, Gtk.Widget>("start", "GtkWidget", "packStart", "remove"),
+            methodSlot<Gtk.HeaderBar | Gtk.ActionBar, Gtk.Widget>("end", "GtkWidget", "packEnd", "remove"),
         ],
     }),
     GtkWindow: {
@@ -83,24 +64,10 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
                     popover.unparent();
                 },
             }),
-            addRemoveSlot<Gtk.EventController, Gtk.Widget>(
-                "controllers",
-                "GtkEventController",
-                (widget, controller) => {
-                    widget.addController(controller);
-                },
-                (widget, controller) => {
-                    widget.removeController(controller);
-                },
+            methodSlot<Gtk.Widget, Gtk.EventController>(
+                "controllers", "GtkEventController", "addController", "removeController",
             ),
-            slot<Gtk.Widget, Gtk.LayoutManager>("layoutManager", "GtkLayoutManager", {
-                attach: (widget, manager) => {
-                    widget.setLayoutManager(manager);
-                },
-                detach: (widget) => {
-                    widget.setLayoutManager(null);
-                },
-            }),
+            setterSlot<Gtk.Widget, Gtk.LayoutManager>("layoutManager", "GtkLayoutManager", "setLayoutManager"),
             slot<Gtk.Widget, Gio.ActionGroup>("actionGroups", "GActionGroup", {
                 attach: (widget, group, info) => {
                     widget.insertActionGroup((info.props.prefix as string | null) ?? "", group);
@@ -146,15 +113,8 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     },
     GtkShortcutController: {
         behaviors: [
-            addRemoveSlot<Gtk.Shortcut, Gtk.ShortcutController>(
-                "shortcuts",
-                "GtkShortcut",
-                (controller, shortcut) => {
-                    controller.addShortcut(shortcut);
-                },
-                (controller, shortcut) => {
-                    controller.removeShortcut(shortcut);
-                },
+            methodSlot<Gtk.ShortcutController, Gtk.Shortcut>(
+                "shortcuts", "GtkShortcut", "addShortcut", "removeShortcut",
             ),
         ],
     },
@@ -162,16 +122,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
         behaviors: [{ create: () => Gtk.TextChildAnchor.new() }],
     },
     GtkTextView: {
-        behaviors: [
-            slot<Gtk.TextView, Gtk.TextBuffer>("children", "GtkTextBuffer", {
-                attach: (view, buffer) => {
-                    view.setBuffer(buffer);
-                },
-                detach: (view) => {
-                    view.setBuffer(null);
-                },
-            }),
-        ],
+        behaviors: [setterSlot<Gtk.TextView, Gtk.TextBuffer>("children", "GtkTextBuffer", "setBuffer")],
     },
     GActionMap: {
         behaviors: [
@@ -249,25 +200,11 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     },
     GtkConstraintLayout: {
         behaviors: [
-            addRemoveSlot<Gtk.Constraint, Gtk.ConstraintLayout>(
-                "constraints",
-                "GtkConstraint",
-                (layout, constraint) => {
-                    layout.addConstraint(constraint);
-                },
-                (layout, constraint) => {
-                    layout.removeConstraint(constraint);
-                },
+            methodSlot<Gtk.ConstraintLayout, Gtk.Constraint>(
+                "constraints", "GtkConstraint", "addConstraint", "removeConstraint",
             ),
-            addRemoveSlot<Gtk.ConstraintGuide, Gtk.ConstraintLayout>(
-                "guides",
-                "GtkConstraintGuide",
-                (layout, guide) => {
-                    layout.addGuide(guide);
-                },
-                (layout, guide) => {
-                    layout.removeGuide(guide);
-                },
+            methodSlot<Gtk.ConstraintLayout, Gtk.ConstraintGuide>(
+                "guides", "GtkConstraintGuide", "addGuide", "removeGuide",
             ),
             list<Gtk.ConstraintLayout, VflConstraints, Gtk.Constraint[]>("vfl", {
                 add: (layout, item) => [
@@ -288,13 +225,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     },
     GtkStack: {
         behaviors: [
-            adoptedChildrenSlot<Gtk.Stack, Gtk.Widget>(
-                "GtkWidget",
-                (stack, child) => stack.addChild(child),
-                (stack, child) => {
-                    stack.remove(child);
-                },
-            ),
+            methodSlot<Gtk.Stack, Gtk.Widget>("children", "GtkWidget", "addChild", "remove"),
             deferred<Gtk.Stack, string>("visibleChildName", (stack, name) => stack.getChildByName(name) !== null),
         ],
     },
@@ -315,16 +246,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     GtkApplication: {
         behaviors: [
             applicationCreator(Gtk.Application),
-            addRemoveSlot<Gtk.Window, Gtk.Application>(
-                "children",
-                "GtkWindow",
-                (application, window) => {
-                    application.addWindow(window);
-                },
-                (application, window) => {
-                    application.removeWindow(window);
-                },
-            ),
+            methodSlot<Gtk.Application, Gtk.Window>("children", "GtkWindow", "addWindow", "removeWindow"),
             list<Gtk.Application, ActionAccel>("actionAccels", {
                 add: (application, item) => {
                     application.setAccelsForAction(item.detailedActionName, item.accels);
@@ -494,89 +416,27 @@ function desiredIndex(value: unknown): number | undefined {
     return value;
 }
 
-function selectRowAt(box: Gtk.ListBox, row: Gtk.ListBoxRow): void {
-    applyWrite(SELECTED_INDEX_PROP, () => {
-        box.selectRow(row);
-    });
-}
-
-function clearSelection(box: Gtk.ListBox): void {
-    applyWrite(SELECTED_INDEX_PROP, () => {
+function applySelectedIndex(box: Gtk.ListBox, index: number): void {
+    if (index < 0) {
         box.unselectAll();
-    });
-}
-
-function applySelectedIndex(box: Gtk.ListBox, state: SelectedIndexState): void {
-    const { desired } = state;
 
-    if (desired === undefined || selectedRowIndex(box) === desired) {
         return;
     }
 
-    if (desired < 0) {
-        clearSelection(box);
-
-        return;
-    }
-
-    const row = box.getRowAtIndex(desired);
+    const row = box.getRowAtIndex(index);
 
     if (row !== null) {
-        selectRowAt(box, row);
-    }
-}
-
-function scheduleSelectedIndex(box: Gtk.ListBox, state: SelectedIndexState): void {
-    if (state.isScheduled) {
-        return;
-    }
-
-    state.isScheduled = true;
-
-    queueMicrotask(() => {
-        state.isScheduled = false;
-
-        if (state.disconnect !== null) {
-            applySelectedIndex(box, state);
-        }
-    });
-}
-
-function watchSelectionDrift(box: Gtk.ListBox, state: SelectedIndexState): void {
-    if (state.disconnect !== null) {
-        return;
+        box.selectRow(row);
     }
-
-    const handler = (): undefined => {
-        scheduleSelectedIndex(box, state);
-    };
-
-    box.on(SELECTION_SIGNAL, handler);
-
-    state.disconnect = (): void => {
-        box.off(SELECTION_SIGNAL, handler);
-    };
 }
 
 function selectedIndexBehavior(): ElementBehavior<Gtk.ListBox> {
-    return {
-        deferred: [SELECTED_INDEX_PROP],
-        initialize: (): SelectedIndexState => ({ desired: undefined, isScheduled: false, disconnect: null }),
-        update: (_box, _prev, next, context) => {
-            (context as SelectedIndexState).desired = desiredIndex(next[SELECTED_INDEX_PROP]);
-
-            return [SELECTED_INDEX_PROP];
-        },
-        flush: (box, context) => {
-            applySelectedIndex(box, context as SelectedIndexState);
-            watchSelectionDrift(box, context as SelectedIndexState);
-        },
-        teardown: (_box, context) => {
-            const state = context as SelectedIndexState;
-            state.disconnect?.();
-            state.disconnect = null;
-        },
-    };
+    return deferredWith<Gtk.ListBox, number>(SELECTED_INDEX_PROP, {
+        parse: desiredIndex,
+        read: selectedRowIndex,
+        write: applySelectedIndex,
+        signal: SELECTION_SIGNAL,
+    });
 }
 
 const addMainOption = (application: Gtk.Application, option: MainOption): void => {