@gtkx/react 0.6.0 → 0.7.0

package/dist/batch.d.ts

@@ -2,11 +2,14 @@ type FlushCallback = () => void;
 /**
  * Marks the beginning of a React reconciler commit phase.
  * While in commit, flush callbacks are deferred until endCommit is called.
+ * Supports nested commits through depth tracking.
  */
 export declare const beginCommit: () => void;
 /**
  * Marks the end of a React reconciler commit phase.
- * Executes all pending flush callbacks that were deferred during the commit.
+ * Executes all pending flush callbacks that were deferred during the commit
+ * only when the outermost commit ends (depth reaches 0).
+ * If called without a matching beginCommit, resets the state (useful for test cleanup).
  */
 export declare const endCommit: () => void;
 /**

package/dist/batch.js

@@ -1,21 +1,30 @@
-const pendingFlushes = new Set();
-let inCommit = false;
+const state = {
+    depth: 0,
+    pendingFlushes: new Set(),
+};
 /**
  * Marks the beginning of a React reconciler commit phase.
  * While in commit, flush callbacks are deferred until endCommit is called.
+ * Supports nested commits through depth tracking.
  */
 export const beginCommit = () => {
-    inCommit = true;
+    state.depth++;
 };
 /**
  * Marks the end of a React reconciler commit phase.
- * Executes all pending flush callbacks that were deferred during the commit.
+ * Executes all pending flush callbacks that were deferred during the commit
+ * only when the outermost commit ends (depth reaches 0).
+ * If called without a matching beginCommit, resets the state (useful for test cleanup).
  */
 export const endCommit = () => {
-    inCommit = false;
-    if (pendingFlushes.size > 0) {
-        const callbacks = [...pendingFlushes];
-        pendingFlushes.clear();
+    if (state.depth <= 0) {
+        state.depth = 0;
+        return;
+    }
+    state.depth--;
+    if (state.depth === 0 && state.pendingFlushes.size > 0) {
+        const callbacks = [...state.pendingFlushes];
+        state.pendingFlushes.clear();
         queueMicrotask(() => {
             for (const callback of callbacks) {
                 callback();
@@ -28,8 +37,8 @@ export const endCommit = () => {
  * This ensures GTK state updates happen after React has finished its batch of changes.
  */
 export const scheduleFlush = (callback) => {
-    if (inCommit) {
-        pendingFlushes.add(callback);
+    if (state.depth > 0) {
+        state.pendingFlushes.add(callback);
     }
     else {
         callback();

package/dist/codegen/jsx-generator.d.ts

@@ -2,19 +2,19 @@ import type { GirClass, GirNamespace, TypeMapper, TypeRegistry } from "@gtkx/gir
 /**
  * Configuration options for the JSX type generator.
  */
-interface JsxGeneratorOptions {
+type JsxGeneratorOptions = {
     /** Optional Prettier configuration for formatting output. */
     prettierConfig?: unknown;
-}
+};
 /**
  * Result of the JSX generation containing both public and internal files.
  */
-interface JsxGeneratorResult {
+type JsxGeneratorResult = {
     /** Public JSX types and components for user consumption. */
     jsx: string;
     /** Internal metadata for reconciler use (not exported to users). */
     internal: string;
-}
+};
 /**
  * Generates JSX type definitions for React components from GTK widget classes.
  * Creates TypeScript interfaces for props and augments React's JSX namespace.

package/dist/codegen/jsx-generator.js

@@ -5,7 +5,7 @@ const COLUMN_VIEW_WIDGET = "ColumnView";
 const DROPDOWN_WIDGETS = new Set(["DropDown"]);
 const GRID_WIDGETS = new Set(["Grid"]);
 const NOTEBOOK_WIDGET = "Notebook";
-const STACK_WIDGET = "Stack";
+const STACK_WIDGETS = new Set(["Stack", "ViewStack", "AdwViewStack"]);
 const POPOVER_MENU_WIDGET = "PopoverMenu";
 const TOOLBAR_VIEW_WIDGET = "ToolbarView";
 const INTERNALLY_PROVIDED_PARAMS = {
@@ -37,7 +37,7 @@ const isColumnViewWidget = (widgetName) => widgetName === COLUMN_VIEW_WIDGET;
 const isDropDownWidget = (widgetName) => DROPDOWN_WIDGETS.has(widgetName);
 const isGridWidget = (widgetName) => GRID_WIDGETS.has(widgetName);
 const isNotebookWidget = (widgetName) => widgetName === NOTEBOOK_WIDGET;
-const isStackWidget = (widgetName) => widgetName === STACK_WIDGET;
+const isStackWidget = (widgetName) => STACK_WIDGETS.has(widgetName);
 const isPopoverMenuWidget = (widgetName) => widgetName === POPOVER_MENU_WIDGET;
 const isToolbarViewWidget = (widgetName) => widgetName === TOOLBAR_VIEW_WIDGET;
 const sanitizeDoc = (doc) => {
@@ -162,7 +162,7 @@ export class JsxGenerator {
             `import { createElement } from "react";`,
             `import type { ReactNode, Ref } from "react";`,
             ...namespaceImports,
-            `import type { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps } from "../types.js";`,
+            `import type { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps } from "../types.js";`,
             "",
         ].join("\n");
     }
@@ -174,7 +174,7 @@ export class JsxGenerator {
         this.typeMapper.setTypeRegistry(this.typeRegistry, "Gtk");
         const widgetPropsContent = this.generateWidgetPropsContent(widgetClass);
         return `
-export { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps };
+export { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps };
 
 ${widgetPropsContent}
 `;
@@ -382,6 +382,15 @@ ${widgetPropsContent}
                 lines.push(`\t${this.generateSignalHandler(signal, widget.name)}`);
             }
         }
+        if (isListWidget(widget.name) || isColumnViewWidget(widget.name)) {
+            lines.push("");
+            lines.push(`\t/** Array of selected item IDs */`);
+            lines.push(`\tselected?: string[];`);
+            lines.push(`\t/** Called when selection changes with array of selected item IDs */`);
+            lines.push(`\tonSelectionChanged?: (ids: string[]) => void;`);
+            lines.push(`\t/** Selection mode: SINGLE (default) or MULTIPLE */`);
+            lines.push(`\tselectionMode?: import("@gtkx/ffi/gtk").SelectionMode;`);
+        }
         if (isListWidget(widget.name)) {
             lines.push("");
             lines.push(`\t/**`);
@@ -392,10 +401,10 @@ ${widgetPropsContent}
         }
         if (isDropDownWidget(widget.name)) {
             lines.push("");
-            lines.push(`\t/** Function to convert item to display label */`);
-            lines.push(`\titemLabel?: (item: unknown) => string;`);
-            lines.push(`\t/** Called when selection changes */`);
-            lines.push(`\tonSelectionChanged?: (item: unknown, index: number) => void;`);
+            lines.push(`\t/** ID of the initially selected item */`);
+            lines.push(`\tselectedId?: string;`);
+            lines.push(`\t/** Called when selection changes with the selected item's ID */`);
+            lines.push(`\tonSelectionChanged?: (id: string) => void;`);
         }
         lines.push("");
         const ffiTypeName = toPascalCase(widget.name);
@@ -830,13 +839,12 @@ export const Menu = {
         }
         else if (isColumnViewWidget(widgetName)) {
             lines.push(`/**`);
-            lines.push(` * Props for the ${name}.Root component with type-safe item and column rendering.`);
-            lines.push(` * @typeParam T - The type of items in the column view.`);
-            lines.push(` * @typeParam C - The union type of column IDs for type-safe sorting.`);
+            lines.push(` * Props for the ${name}.Root component with column sorting UI indicators.`);
+            lines.push(` * @typeParam C - The union type of column IDs for type-safe sorting indicators.`);
             lines.push(` */`);
-            lines.push(`interface ${name}RootPropsExtended<T = unknown, C extends string = string> extends ${name}Props, ColumnViewRootProps<T, C> {}`);
+            lines.push(`interface ${name}RootPropsExtended<C extends string = string> extends ${name}Props, ColumnViewRootProps<C> {}`);
             lines.push(``);
-            lines.push(`function ${name}Root<T = unknown, C extends string = string>(props: ${name}RootPropsExtended<T, C>): import("react").ReactElement {`);
+            lines.push(`function ${name}Root<C extends string = string>(props: ${name}RootPropsExtended<C>): import("react").ReactElement {`);
             lines.push(`\treturn createElement("${name}.Root", props);`);
             lines.push(`}`);
             lines.push(``);
@@ -858,22 +866,11 @@ export const Menu = {
             lines.push(`}`);
         }
         else if (isDropDownWidget(widgetName)) {
-            lines.push(`/**`);
-            lines.push(` * Props for the ${name}.Root component with type-safe item handling.`);
-            lines.push(` * @typeParam T - The type of items in the dropdown.`);
-            lines.push(` */`);
-            lines.push(`interface ${name}RootProps<T> extends Omit<${name}Props, "itemLabel" | "onSelectionChanged"> {`);
-            lines.push(`\t/** Function to convert an item to its display label. */`);
-            lines.push(`\titemLabel?: (item: T) => string;`);
-            lines.push(`\t/** Called when the selected item changes. */`);
-            lines.push(`\tonSelectionChanged?: (item: T | null, index: number) => void;`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Root<T>(props: ${name}RootProps<T>): import("react").ReactElement {`);
+            lines.push(`function ${name}Root(props: ${name}Props): import("react").ReactElement {`);
             lines.push(`\treturn createElement("${name}.Root", props);`);
             lines.push(`}`);
             lines.push(``);
-            lines.push(`function ${name}Item<T>(props: ListItemProps<T>): import("react").ReactElement {`);
+            lines.push(`function ${name}Item(props: StringListItemProps): import("react").ReactElement {`);
             lines.push(`\treturn createElement("${name}.Item", props);`);
             lines.push(`}`);
         }
@@ -949,7 +946,7 @@ export const Menu = {
                 elements.push(`"${widgetName}.Item": ListItemProps;`);
             }
             if (isDropDownWidget(widget.name)) {
-                elements.push(`"${widgetName}.Item": ListItemProps;`);
+                elements.push(`"${widgetName}.Item": StringListItemProps;`);
             }
             if (isGridWidget(widget.name)) {
                 elements.push(`"${widgetName}.Child": GridChildProps;`);

package/dist/container-interfaces.d.ts

@@ -20,6 +20,7 @@ export type PageContainer = {
 };
 /**
  * Props for Stack pages.
+ * Used by Gtk.Stack and Adw.ViewStack.
  */
 export type StackPageProps = {
     name?: string;
@@ -28,6 +29,7 @@ export type StackPageProps = {
     needsAttention?: boolean;
     visible?: boolean;
     useUnderline?: boolean;
+    badgeNumber?: number;
 };
 /**
  * Type for Stack containers.
@@ -46,12 +48,14 @@ export type GridContainer = {
     removeFromGrid(child: Gtk.Widget): void;
 };
 /**
- * Type for item-based containers like ListView, ColumnView, DropDown.
+ * Type for item-based containers like ListView, GridView, ColumnView.
+ * Items are identified by string IDs for selection support.
  */
 export type ItemContainer<T> = {
-    addItem(item: T): void;
-    insertItemBefore(item: T, beforeItem: T): void;
-    removeItem(item: T): void;
+    addItem(id: string, item: T): void;
+    insertItemBefore(id: string, item: T, beforeId: string): void;
+    removeItem(id: string): void;
+    updateItem(id: string, item: T): void;
 };
 /**
  * Type for column-based containers like ColumnView.
@@ -62,11 +66,20 @@ export type ColumnContainer = {
     insertColumnBefore(column: unknown, beforeColumn: unknown): void;
     removeColumn(column: unknown): void;
     getItems(): unknown[];
-    getSortFn(): ((a: unknown, b: unknown, columnId: string) => number) | null;
 };
 export declare const isChildContainer: (node: Node) => node is Node & ChildContainer;
 export declare const isPageContainer: (node: Node) => node is Node & PageContainer;
 export declare const isStackPageContainer: (node: Node) => node is Node & StackPageContainer;
 export declare const isGridContainer: (node: Node) => node is Node & GridContainer;
-export declare const isItemContainer: <T>(node: Node) => node is Node & ItemContainer<T>;
+export declare const isItemContainer: (node: Node) => node is Node & ItemContainer<unknown>;
 export declare const isColumnContainer: (node: Node) => node is Node & ColumnContainer;
+/**
+ * Type for containers that support packStart/packEnd semantics.
+ * Used by HeaderBar, ActionBar.
+ */
+export type PackContainer = {
+    packStart(child: Gtk.Widget): void;
+    packEnd(child: Gtk.Widget): void;
+    removeFromPack(child: Gtk.Widget): void;
+};
+export declare const isPackContainer: (node: Node) => node is Node & PackContainer;

package/dist/container-interfaces.js

@@ -1,6 +1,26 @@
-export const isChildContainer = (node) => "attachChild" in node && "detachChild" in node && "insertChildBefore" in node;
-export const isPageContainer = (node) => "addPage" in node && "removePage" in node && "insertPageBefore" in node && "updatePageLabel" in node;
-export const isStackPageContainer = (node) => "addStackPage" in node && "removeStackPage" in node && "updateStackPageProps" in node;
-export const isGridContainer = (node) => "attachToGrid" in node && "removeFromGrid" in node;
-export const isItemContainer = (node) => "addItem" in node && "insertItemBefore" in node && "removeItem" in node;
-export const isColumnContainer = (node) => "addColumn" in node && "removeColumn" in node && "getSortFn" in node;
+const createContainerGuard = (requiredMethods) => (node) => requiredMethods.every((method) => method in node);
+export const isChildContainer = createContainerGuard([
+    "attachChild",
+    "detachChild",
+    "insertChildBefore",
+]);
+export const isPageContainer = createContainerGuard([
+    "addPage",
+    "removePage",
+    "insertPageBefore",
+    "updatePageLabel",
+]);
+export const isStackPageContainer = createContainerGuard([
+    "addStackPage",
+    "removeStackPage",
+    "updateStackPageProps",
+]);
+export const isGridContainer = createContainerGuard(["attachToGrid", "removeFromGrid"]);
+export const isItemContainer = createContainerGuard([
+    "addItem",
+    "insertItemBefore",
+    "removeItem",
+    "updateItem",
+]);
+export const isColumnContainer = createContainerGuard(["addColumn", "removeColumn", "getItems"]);
+export const isPackContainer = createContainerGuard(["packStart", "packEnd", "removeFromPack"]);

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class GTKXError extends Error {
+    widgetType?: string | undefined;
+    componentStack?: string | undefined;
+    constructor(message: string, widgetType?: string | undefined, componentStack?: string | undefined);
+    toString(): string;
+}
+export declare function formatRenderError(error: unknown, widgetType?: string): GTKXError;
+export declare function formatBoundaryError(error: unknown): GTKXError;

package/dist/errors.js

@@ -0,0 +1,38 @@
+export class GTKXError extends Error {
+    widgetType;
+    componentStack;
+    constructor(message, widgetType, componentStack) {
+        super(message);
+        this.widgetType = widgetType;
+        this.componentStack = componentStack;
+        this.name = "GTKXError";
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, GTKXError);
+        }
+    }
+    toString() {
+        const parts = [`GTKXError: ${this.message}`];
+        if (this.widgetType) {
+            parts.push(`Widget Type: ${this.widgetType}`);
+        }
+        if (this.componentStack) {
+            parts.push(`Component Stack:\n${this.componentStack}`);
+        }
+        return parts.join("\n");
+    }
+}
+export function formatRenderError(error, widgetType) {
+    if (error instanceof GTKXError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const formattedMessage = widgetType ? `Failed to render ${widgetType}: ${message}` : `Render error: ${message}`;
+    return new GTKXError(formattedMessage, widgetType);
+}
+export function formatBoundaryError(error) {
+    if (error instanceof GTKXError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new GTKXError(`Error caught by boundary: ${message}`);
+}

package/dist/factory.js

@@ -1,12 +1,13 @@
 import { AboutDialogNode } from "./nodes/about-dialog.js";
 import { ActionBarNode } from "./nodes/action-bar.js";
 import { ColumnViewColumnNode, ColumnViewItemNode, ColumnViewNode } from "./nodes/column-view.js";
-import { DropDownItemNode, DropDownNode } from "./nodes/dropdown.js";
+import { ComboRowNode } from "./nodes/combo-row.js";
+import { DropDownItemNode, DropDownNode } from "./nodes/drop-down.js";
 import { FlowBoxNode } from "./nodes/flow-box.js";
 import { GridChildNode, GridNode } from "./nodes/grid.js";
-import { AdwHeaderBarNode, HeaderBarNode } from "./nodes/header-bar.js";
-import { ListItemNode, ListViewNode } from "./nodes/list.js";
+import { AdwHeaderBarNode, HeaderBarNode, PackEndNode, PackStartNode } from "./nodes/header-bar.js";
 import { ListBoxNode } from "./nodes/list-box.js";
+import { ListItemNode, ListViewNode } from "./nodes/list-view.js";
 import { ApplicationMenuNode, MenuItemNode, MenuSectionNode, MenuSubmenuNode, PopoverMenuBarNode, PopoverMenuRootNode, } from "./nodes/menu.js";
 import { NotebookNode, NotebookPageNode } from "./nodes/notebook.js";
 import { OverlayNode } from "./nodes/overlay.js";
@@ -16,6 +17,7 @@ import { StackNode, StackPageNode } from "./nodes/stack.js";
 import { TextViewNode } from "./nodes/text-view.js";
 import { ToggleButtonNode } from "./nodes/toggle-button.js";
 import { ToolbarViewSlotNode } from "./nodes/toolbar-view.js";
+import { ViewStackNode } from "./nodes/view-stack.js";
 import { WidgetNode } from "./nodes/widget.js";
 import { WindowNode } from "./nodes/window.js";
 export { ROOT_NODE_CONTAINER } from "./nodes/root.js";
@@ -31,6 +33,8 @@ const VIRTUAL_NODES = [
     MenuSectionNode,
     MenuSubmenuNode,
     ToolbarViewSlotNode,
+    PackStartNode,
+    PackEndNode,
     SlotNode,
 ];
 const SPECIALIZED_NODES = [
@@ -47,12 +51,14 @@ const CONTAINER_NODES = [
     FlowBoxNode,
     ListBoxNode,
     DropDownNode,
+    ComboRowNode,
     GridNode,
     OverlayNode,
     ColumnViewNode,
     ListViewNode,
     NotebookNode,
     StackNode,
+    ViewStackNode,
     AdwHeaderBarNode,
     HeaderBarNode,
 ];

package/dist/generated/jsx.d.ts

@@ -12,8 +12,8 @@ import type * as Pango from "@gtkx/ffi/pango";
 import type * as Vte from "@gtkx/ffi/vte";
 import type * as WebKit from "@gtkx/ffi/webkit";
 import type * as cairo from "@gtkx/ffi/cairo";
-import type { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps } from "../types.js";
-export { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, };
+import type { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps } from "../types.js";
+export { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps, };
 /**
  * The base class for all widgets.
  *
@@ -1599,6 +1599,12 @@ export interface ColumnViewProps extends WidgetProps {
      * signal.
      */
     onActivate?: (self: Gtk.ColumnView, position: number) => void;
+    /** Array of selected item IDs */
+    selected?: string[];
+    /** Called when selection changes with array of selected item IDs */
+    onSelectionChanged?: (ids: string[]) => void;
+    /** Selection mode: SINGLE (default) or MULTIPLE */
+    selectionMode?: import("@gtkx/ffi/gtk").SelectionMode;
     ref?: Ref<Gtk.ColumnView>;
 }
 /** Props for the {@link ComboBox} widget. */
@@ -1869,10 +1875,10 @@ export interface DropDownProps extends WidgetProps {
      * emitting it causes the drop down to pop up its dropdown.
      */
     onActivate?: (self: Gtk.DropDown) => void;
-    /** Function to convert item to display label */
-    itemLabel?: (item: unknown) => string;
-    /** Called when selection changes */
-    onSelectionChanged?: (item: unknown, index: number) => void;
+    /** ID of the initially selected item */
+    selectedId?: string;
+    /** Called when selection changes with the selected item's ID */
+    onSelectionChanged?: (id: string) => void;
     ref?: Ref<Gtk.DropDown>;
 }
 /** Props for the {@link EditableLabel} widget. */
@@ -2922,6 +2928,12 @@ export interface GridViewProps extends ListBaseProps {
      * this signal.
      */
     onActivate?: (self: Gtk.GridView, position: number) => void;
+    /** Array of selected item IDs */
+    selected?: string[];
+    /** Called when selection changes with array of selected item IDs */
+    onSelectionChanged?: (ids: string[]) => void;
+    /** Selection mode: SINGLE (default) or MULTIPLE */
+    selectionMode?: import("@gtkx/ffi/gtk").SelectionMode;
     /**
      * Render function for list items.
      * Called with null during setup (for loading state) and with the actual item during bind.
@@ -3742,6 +3754,12 @@ export interface ListViewProps extends ListBaseProps {
      * this signal.
      */
     onActivate?: (self: Gtk.ListView, position: number) => void;
+    /** Array of selected item IDs */
+    selected?: string[];
+    /** Called when selection changes with array of selected item IDs */
+    onSelectionChanged?: (ids: string[]) => void;
+    /** Selection mode: SINGLE (default) or MULTIPLE */
+    selectionMode?: import("@gtkx/ffi/gtk").SelectionMode;
     /**
      * Render function for list items.
      * Called with null during setup (for loading state) and with the actual item during bind.
@@ -12011,13 +12029,12 @@ export declare const ColorChooserWidget: "ColorChooserWidget";
  */
 export declare const ColorDialogButton: "ColorDialogButton";
 /**
- * Props for the ColumnView.Root component with type-safe item and column rendering.
- * @typeParam T - The type of items in the column view.
- * @typeParam C - The union type of column IDs for type-safe sorting.
+ * Props for the ColumnView.Root component with column sorting UI indicators.
+ * @typeParam C - The union type of column IDs for type-safe sorting indicators.
  */
-interface ColumnViewRootPropsExtended<T = unknown, C extends string = string> extends ColumnViewProps, ColumnViewRootProps<T, C> {
+interface ColumnViewRootPropsExtended<C extends string = string> extends ColumnViewProps, ColumnViewRootProps<C> {
 }
-declare function ColumnViewRoot<T = unknown, C extends string = string>(props: ColumnViewRootPropsExtended<T, C>): import("react").ReactElement;
+declare function ColumnViewRoot<C extends string = string>(props: ColumnViewRootPropsExtended<C>): import("react").ReactElement;
 /**
  * Props for ColumnView.Column with type-safe cell rendering.
  * @typeParam T - The type of items passed to the renderCell function.
@@ -12439,18 +12456,8 @@ export declare const DragIcon: "DragIcon";
  * creating your own `GtkWidget` subclass.
  */
 export declare const DrawingArea: "DrawingArea";
-/**
- * Props for the DropDown.Root component with type-safe item handling.
- * @typeParam T - The type of items in the dropdown.
- */
-interface DropDownRootProps<T> extends Omit<DropDownProps, "itemLabel" | "onSelectionChanged"> {
-    /** Function to convert an item to its display label. */
-    itemLabel?: (item: T) => string;
-    /** Called when the selected item changes. */
-    onSelectionChanged?: (item: T | null, index: number) => void;
-}
-declare function DropDownRoot<T>(props: DropDownRootProps<T>): import("react").ReactElement;
-declare function DropDownItem<T>(props: ListItemProps<T>): import("react").ReactElement;
+declare function DropDownRoot(props: DropDownProps): import("react").ReactElement;
+declare function DropDownItem(props: StringListItemProps): import("react").ReactElement;
 /**
  * Allows the user to choose an item from a list of options.
  *
@@ -19628,6 +19635,9 @@ export declare const AdwToolbarView: {
     Top: "AdwToolbarView.Top";
     Bottom: "AdwToolbarView.Bottom";
 };
+declare function AdwViewStackRoot(props: StackRootProps & AdwViewStackProps): import("react").ReactElement;
+declare function AdwViewStackPage(props: StackPageProps): import("react").ReactElement;
+declare function AdwViewStackVisibleChild(props: SlotProps): import("react").ReactElement;
 /**
  * A view container for [class@ViewSwitcher].
  *
@@ -19687,8 +19697,9 @@ export declare const AdwToolbarView: {
  * which are the accessible parent objects of the child widgets.
  */
 export declare const AdwViewStack: {
-    Root: "AdwViewStack.Root";
-    VisibleChild: "AdwViewStack.VisibleChild";
+    Root: typeof AdwViewStackRoot;
+    Page: typeof AdwViewStackPage;
+    VisibleChild: typeof AdwViewStackVisibleChild;
 };
 /**
  * An adaptive view switcher.
@@ -20254,7 +20265,7 @@ declare global {
                 "DragIcon.Child": SlotProps;
                 DrawingArea: DrawingAreaProps;
                 "DropDown.Root": DropDownProps;
-                "DropDown.Item": ListItemProps;
+                "DropDown.Item": StringListItemProps;
                 EditableLabel: EditableLabelProps;
                 EmojiChooser: EmojiChooserProps;
                 Entry: EntryProps;
@@ -20454,6 +20465,7 @@ declare global {
                 "AdwToolbarView.Bottom": SlotProps;
                 "AdwViewStack.Root": AdwViewStackProps;
                 "AdwViewStack.VisibleChild": SlotProps;
+                "AdwViewStack.Page": StackPageProps;
                 AdwViewSwitcher: AdwViewSwitcherProps;
                 AdwViewSwitcherBar: AdwViewSwitcherBarProps;
                 AdwViewSwitcherTitle: AdwViewSwitcherTitleProps;

package/dist/generated/jsx.js

@@ -8749,6 +8749,15 @@ export const AdwToolbarView = {
     Top: "AdwToolbarView.Top",
     Bottom: "AdwToolbarView.Bottom",
 };
+function AdwViewStackRoot(props) {
+    return createElement("AdwViewStack.Root", props);
+}
+function AdwViewStackPage(props) {
+    return createElement("AdwViewStack.Page", props);
+}
+function AdwViewStackVisibleChild(props) {
+    return createElement("AdwViewStack.VisibleChild", props);
+}
 /**
  * A view container for [class@ViewSwitcher].
  *
@@ -8808,8 +8817,9 @@ export const AdwToolbarView = {
  * which are the accessible parent objects of the child widgets.
  */
 export const AdwViewStack = {
-    Root: "AdwViewStack.Root",
-    VisibleChild: "AdwViewStack.VisibleChild",
+    Root: AdwViewStackRoot,
+    Page: AdwViewStackPage,
+    VisibleChild: AdwViewStackVisibleChild,
 };
 /**
  * An adaptive view switcher.

package/dist/index.js

@@ -10,7 +10,7 @@ export { reconciler } from "./reconciler.js";
 export { render } from "./render.js";
 import { stop } from "@gtkx/ffi";
 import { reconciler } from "./reconciler.js";
-import { container } from "./render.js";
+import { getContainer } from "./render.js";
 /**
  * Updates the React tree without restarting the GTK application.
  * Used for hot module replacement (HMR) during development.
@@ -19,6 +19,7 @@ import { container } from "./render.js";
  * @throws Error if called before render()
  */
 export const update = (element) => {
+    const container = getContainer();
     if (!container) {
         throw new Error("Cannot update before render() is called");
     }
@@ -30,6 +31,7 @@ export const update = (element) => {
  * @returns Always returns true (useful for signal handlers)
  */
 export const quit = () => {
+    const container = getContainer();
     if (container) {
         reconciler.getInstance().updateContainer(null, container, null, () => {
             setTimeout(() => {

package/dist/node.d.ts

@@ -1,11 +1,14 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props, ROOT_NODE_CONTAINER } from "./factory.js";
+export declare const normalizeWidgetType: (type: string) => string;
 export declare abstract class Node<T extends Gtk.Widget | undefined = Gtk.Widget | undefined, S extends object | undefined = object | undefined> {
     static matches(_type: string, _existingWidget?: Gtk.Widget | typeof ROOT_NODE_CONTAINER): boolean;
+    static consumedPropNames: string[];
     protected signalHandlers: Map<string, number>;
     protected widget: T;
     protected widgetType: string;
     protected nodeType: string;
+    protected parent: Node | null;
     private _state;
     protected get state(): S;
     protected set state(value: S);
@@ -23,6 +26,8 @@ export declare abstract class Node<T extends Gtk.Widget | undefined = Gtk.Widget
     insertBefore(child: Node, before: Node): void;
     attachToParent(parent: Node): void;
     detachFromParent(parent: Node): void;
+    protected disconnectAllSignals(): void;
+    hasParent(): boolean;
     attachToParentBefore(parent: Node, before: Node): void;
     protected consumedProps(): Set<string>;
     updateProps(oldProps: Props, newProps: Props): void;