@gjsify/adwaita-nativescript 0.47.0 → 0.49.0

package/lib/types/widgets/gtk-box.d.ts

@@ -0,0 +1,75 @@
+import { StackLayout, type View } from '@nativescript/core';
+import { DEFAULT_BOX_SPACING } from './box-layout.js';
+import { type ConstructProps } from './construct-props.js';
+export { DEFAULT_BOX_SPACING };
+declare const GtkBox_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof StackLayout;
+export declare class GtkBox extends GtkBox_base {
+    private _spacing;
+    private _styleClasses;
+    constructor(props?: ConstructProps<GtkBox>);
+    /** Append a child — `gtk_box_append`. */
+    append(view: View): void;
+    /** Insert a child at the START — `gtk_box_prepend`. */
+    prepend(view: View): void;
+    /** Remove a previously-added child — `gtk_box_remove`. */
+    remove(view: View): void;
+    /**
+     * Every path a child can enter by — `append()`, a direct `addChild()`, and XML
+     * inflation through `_addChildFromBuilder` — ends here, which is why the spacing is
+     * applied here and not in `append()`. `AdwWrapBox` records the incident that rule
+     * comes from: applied in `append()` only, a child declared in markup got no spacing
+     * at all.
+     */
+    addChild(view: View): void;
+    /**
+     * `gtk_box_insert_child_after`.
+     *
+     * A NULL/absent `sibling` inserts at the FIRST position, not the last —
+     * `gtk_widget_insert_after`'s documented rule. Returns whether the insert happened; a
+     * refusal is where C would have hit a `g_return_if_fail`.
+     */
+    insert_child_after(view: View, sibling?: View | null): boolean;
+    /** `gtk_box_reorder_child_after`. Same NULL rule. */
+    reorder_child_after(view: View, sibling?: View | null): boolean;
+    /** `Gtk.Box:spacing` — the gap between children, in DIPs. Defaults to 0, as in C. */
+    get spacing(): number;
+    set spacing(value: number | string);
+    /**
+     * `GtkWidget:css-classes`, spelled `styleClasses` — the platform owns `cssClasses` as a
+     * live `Set`, and taking that name is fatal inside the widget's own constructor
+     * (`style-classes.ts`). From XML it is a space-separated list, which is what an
+     * attribute can carry: `<gtk:Box styleClasses="card" />`.
+     */
+    get styleClasses(): string[];
+    set styleClasses(value: string | null | undefined);
+    /** `gtk_widget_add_css_class`. A class the box already carries is a no-op. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. A class it does not carry is a no-op. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes` — the list, without the widget's own CSS name. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
+    set_css_classes(names: readonly string[]): void;
+    private _setClasses;
+    private _childViews;
+    private _applyOrder;
+    /**
+     * Give every child its share of the gap.
+     *
+     * The WHOLE set, not just the newcomer: adding a second child changes the FIRST one's
+     * answer too when the box is re-ordered, and a removal shifts every index after it.
+     */
+    private _applyChildren;
+}

package/lib/types/widgets/gtk-button.d.ts

@@ -1,33 +1,115 @@
-import { type AdwButtonStyleClass } from '@gjsify/adwaita-core';
-import { Button } from '@nativescript/core';
-/**
- * The Adwaita button variants this widget can apply. `'default'` = plain button.
- *
- * The class list is `@gjsify/adwaita-core`'s, not a local table: this widget's own
- * one was MISSING `circular`, which the browser element had, and neither file could
- * see the other. `circular` is now here because the shared table says it exists.
- *
- * STILL `Adw…`, on a class that is not: the variants ARE libadwaita style classes
- * (`.suggested-action`, `.pill`, `_buttons.scss`), so the prefix names what they are.
- * ADR 0034 clause 1 renames WIDGETS after the library owning their GType; a style-class
- * vocabulary is not a widget, and renaming it would have moved a true name to a false one.
- */
-export type AdwButtonVariant = 'default' | AdwButtonStyleClass;
-export declare class GtkButton extends Button {
-    private _variant;
-    constructor();
+import { GridLayout, type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+/** Event name emitted when the button is tapped. Mirrors `Gtk.Button::clicked`. */
+export declare const GTK_BUTTON_CLICKED = "clicked";
+/** The class the button's own label carries, so the theme can give it Adwaita's type. */
+export declare const GTK_BUTTON_LABEL_CLASS = "adw-button-label";
+declare const GtkButton_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class GtkButton extends GtkButton_base {
+    private _styleClasses;
+    private _label;
+    private _iconName;
+    private _useUnderline;
+    private _slot;
+    /** The view currently in the single cell, whichever slot filled it. */
+    private _content;
+    constructor(props?: ConstructProps<GtkButton>);
     /**
-     * The Adwaita style variant. Setting it swaps the corresponding CSS class
-     * (one of `GtkButton.variantClasses`) onto the button,
-     * preserving the base `adw-button` class. Note that `pill` is the rounded
-     * SHAPE and combines with no other variant here (set the shape OR the accent
-     * intent — matching how this CSS subset expresses them as flat classes).
+     * `Gtk.Button:label` — the button's text.
+     *
+     * Writing it REPLACES whatever was in the child, which is `gtk_button_set_label`
+     * building a fresh `GtkLabel` and handing it to `set_child`. An empty label is still a
+     * label: the button keeps its child and shows nothing, rather than collapsing.
      */
-    get variant(): AdwButtonVariant;
-    set variant(value: AdwButtonVariant);
+    get label(): string;
+    set label(value: string);
     /**
-     * All Adwaita variant class names this widget recognises — exposed for tests
-     * and for consumers composing class lists manually.
+     * `Gtk.Button:icon-name` — an Adwaita symbolic SVG string, not a theme name (see the
+     * header). Writing it replaces the child, as `gtk_button_set_icon_name` does.
      */
-    static get variantClasses(): readonly string[];
+    get iconName(): string;
+    set iconName(value: string);
+    /**
+     * `Gtk.Button:child` — any view, which is how a button wraps an `Adw.ButtonContent`.
+     *
+     * `null` empties the button. Setting it also hands an `AdwButtonContent` the host it
+     * needs: that widget stamps `image-text-button` on the button around it, which C gets
+     * from `gtk_widget_get_ancestor` and NativeScript has no rooting protocol for — so the
+     * button that receives the content is what tells it.
+     */
+    get child(): View | null;
+    set child(view: View | null);
+    /** `gtk_button_set_child`. The method spelling of {@link child}. */
+    set_child(view: View | null): void;
+    /** `gtk_button_get_child`. */
+    get_child(): View | null;
+    /**
+     * XML inflation — every child a template declares is THE button's child.
+     *
+     * Without this, `LayoutBase`'s default calls `addChild`, which drops the view into the
+     * cell without the slot bookkeeping: a second child would paint on top of the first
+     * and `child` would read back `null`, both at exit 0.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
+    /**
+     * `Gtk.Button:use-underline` — whether an `_` in {@link label} marks a mnemonic.
+     *
+     * The marker is REMOVED and no key is bound: NativeScript has no accelerator layer.
+     * Same reduction `Adw.ButtonContent` and `Gtk.Label` make, through the same helper.
+     */
+    get useUnderline(): boolean;
+    set useUnderline(raw: boolean | string);
+    /**
+     * The style classes this button carries (`GtkWidget:css-classes`), without the
+     * `adw-button` class that makes it a button — GTK's own rule for the property.
+     *
+     * IT WAS `variant`, AN ENUM, AND THAT WAS ONE LOOK AT A TIME (ADR 0049). Its own doc
+     * said so: "`pill` is the rounded SHAPE and combines with no other variant here (set
+     * the shape OR the accent intent)". GTK holds a LIST, so `.pill.suggested-action` is
+     * an ordinary Adwaita button and was unreachable through the enum. The names are the
+     * CLASS names now, not the web element's attribute spellings: `suggested-action`,
+     * not `suggested`.
+     *
+     * NOT `cssClasses`: `ViewBase` owns that name as a live `Set<string>` the CSS engine
+     * rebuilds on every `className` write, and shadowing it kills the widget in its own
+     * constructor — see `style-classes.ts`.
+     *
+     * From XML it is a space-separated list, which is what an attribute can carry:
+     * `<gtk:Button styleClasses="pill suggested-action" />`.
+     */
+    get styleClasses(): string[];
+    set styleClasses(value: string | null | undefined);
+    /** `gtk_widget_add_css_class`. A class the button already carries is a no-op. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. A class it does not carry is a no-op. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes` — the list, without the widget's own CSS name. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
+    set_css_classes(names: readonly string[]): void;
+    private _setClasses;
+    /**
+     * Put `value` in the single cell under `wrote`'s slot, detaching whatever the previous
+     * slot had parented.
+     *
+     * The detach is the whole reason `button-slot.ts` exists: two views left in one
+     * `GridLayout` cell paint on top of each other and nothing complains.
+     */
+    private _fill;
+    private _detach;
+    /** Parent `view` in the single cell, centred, and remember it as the content. */
+    private _adopt;
 }
+export {};

package/lib/types/widgets/gtk-drop-down.d.ts

@@ -1,6 +1,7 @@
 import { Label, StackLayout, type EventData } from '@nativescript/core';
-import type { AdwComboOption } from '@gjsify/adwaita-core';
-import { AdwIcon } from './adw-icon.js';
+import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
+import { GtkImage } from './gtk-image.js';
+import { type ConstructProps } from './construct-props.js';
 /** Event name emitted when {@link GtkDropDown.selected} changes through a pick. Mirrors GObject `notify::selected`. */
 export declare const NOTIFY_SELECTED = "notify::selected";
 /** Payload of the `notify::selected` event. */
@@ -12,21 +13,32 @@ export interface NotifyDropDownSelectedEventData extends EventData {
     /** The newly-selected option's `label` — what the button now shows. */
     label: string;
 }
-export declare class GtkDropDown extends StackLayout {
+declare const GtkDropDown_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof StackLayout;
+export declare class GtkDropDown extends GtkDropDown_base {
     /** The button label — the selected option. */
     protected readonly _label: Label;
     /** The down-chevron — a real Adwaita `pan-down-symbolic` icon. */
-    protected readonly _chevron: AdwIcon;
+    protected readonly _chevron: GtkImage;
     /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
     private readonly _state;
     /** Title shown atop the substituted `action()` sheet. */
     private _chooserTitle;
-    constructor();
+    constructor(props?: ConstructProps<GtkDropDown>);
     /** Open the native chooser and apply the picked option. */
     private _openChooser;
-    /** The selectable options. Updates the button label. */
-    get options(): AdwComboOption[];
-    set options(value: AdwComboOption[]);
+    /** The list model (`Gtk.DropDown:model`). Updates the button label. */
+    get model(): AdwComboOption[];
+    set model(value: AdwListModelInput);
     /** The selected option index (`Gtk.DropDown:selected`). */
     get selected(): number;
     set selected(raw: number | string);
@@ -43,3 +55,4 @@ export declare class GtkDropDown extends StackLayout {
     get chooserTitle(): string;
     set chooserTitle(value: string);
 }
+export {};

package/lib/types/widgets/gtk-entry.d.ts

@@ -1,4 +1,5 @@
 import { GridLayout, TextField, type EventData } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
 /** Event name emitted when {@link GtkEntry.text} changes. Mirrors GObject `notify::text`. */
 export declare const NOTIFY_TEXT = "notify::text";
 /** Event name emitted when the return key is pressed — `Gtk.Entry::activate`. */
@@ -10,12 +11,23 @@ export interface NotifyEntryTextEventData extends EventData {
     /** The new number of CHARACTERS (not UTF-16 units). */
     textLength: number;
 }
-export declare class GtkEntry extends GridLayout {
+declare const GtkEntry_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class GtkEntry extends GtkEntry_base {
     /** The real input. Chrome-less: the box around it paints the Adwaita surface. */
     protected readonly _field: TextField;
     private _text;
     private _maxLength;
-    constructor();
+    constructor(props?: ConstructProps<GtkEntry>);
     /**
      * Truncate, write the field, and notify on a real change.
      *
@@ -41,3 +53,4 @@ export declare class GtkEntry extends GridLayout {
     /** The inner `TextField` — for focus, selection and host-specific keyboard options. */
     get field(): TextField;
 }
+export {};

package/lib/types/widgets/gtk-image.d.ts

@@ -0,0 +1,42 @@
+import { Image } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+/** Default decorative-icon size, in DIPs — the Adwaita 16px symbolic grid. */
+export declare const DEFAULT_GTK_IMAGE_SIZE = 16;
+declare const GtkImage_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof Image;
+export declare class GtkImage extends GtkImage_base {
+    private _icon;
+    private _iconColor;
+    private _explicitColor;
+    private _iconSize;
+    private _unsubScheme;
+    constructor(props?: ConstructProps<GtkImage>);
+    /** Adopt the active scheme's default fill (no-op if the caller pinned a colour). */
+    private _syncThemeColor;
+    private _render;
+    /**
+     * The icon to render: an Adwaita icon NAME (`'list-add-symbolic'`) or an Adwaita
+     * symbolic SVG SOURCE string (e.g. `panDownSymbolic`). A name the compiled subset
+     * does not carry draws the `image-missing` glyph; `''` draws nothing.
+     */
+    get iconName(): string;
+    set iconName(value: string);
+    /** The icon fill colour (hex). Setting it PINS the colour (it no longer follows
+     *  the light/dark scheme) — use it for context colours like white on a suggested
+     *  button or destructive red, which must survive both schemes. */
+    get iconColor(): string;
+    set iconColor(value: string);
+    /** The icon size in DIPs (default 16). Re-renders + resizes the image box. */
+    get iconSize(): number;
+    set iconSize(raw: number | string);
+}
+export {};

package/lib/types/widgets/gtk-label.d.ts

@@ -0,0 +1,82 @@
+import { Label } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+declare const GtkLabel_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof Label;
+export declare class GtkLabel extends GtkLabel_base {
+    private _label;
+    private _useMarkup;
+    private _useUnderline;
+    private _styleClasses;
+    constructor(props?: ConstructProps<GtkLabel>);
+    /**
+     * `Gtk.Label:label` — the text, as written, before markup and the mnemonic marker are
+     * taken out of it. `get_text()` is the string actually shown.
+     */
+    get label(): string;
+    set label(value: string);
+    /**
+     * `Gtk.Label:use-markup` — whether {@link label} is Pango markup.
+     *
+     * TRUE means the markup is REDUCED to its plain text here, not rendered: see the
+     * header. FALSE, the default, shows the string literally, so a `<` in a sentence stays
+     * a `<`.
+     */
+    get useMarkup(): boolean;
+    set useMarkup(raw: boolean | string);
+    /**
+     * `Gtk.Label:use-underline` — whether an `_` in {@link label} marks a mnemonic.
+     *
+     * The marker is REMOVED and the key is not bound: NativeScript has no accelerator
+     * layer and no way to underline one character of a `Label`. Same reduction
+     * `Adw.ButtonContent` makes.
+     */
+    get useUnderline(): boolean;
+    set useUnderline(raw: boolean | string);
+    /**
+     * `Gtk.Label:wrap` — whether the text wraps rather than running past its allocation.
+     *
+     * NativeScript's own name for it is `textWrap`, which stays reachable; this is the GIR
+     * spelling over the same platform property, so a snippet ported off GJS runs verbatim.
+     * `wrap-mode` and `natural-wrap-mode` are the declared gaps beside it — the platform
+     * wraps at word boundaries and offers no choice.
+     */
+    get wrap(): boolean;
+    set wrap(raw: boolean | string);
+    /**
+     * `GtkWidget:css-classes`, spelled `styleClasses` for the reason `style-classes.ts`
+     * records: the platform owns `cssClasses` as a live `Set` and taking that name kills
+     * the widget. From XML it is a space-separated list —
+     * `<gtk:Label styleClasses="title-2" />`.
+     */
+    get styleClasses(): string[];
+    set styleClasses(value: string | null | undefined);
+    /** `gtk_label_set_markup` — set the text AND turn markup interpretation on. */
+    set_markup(markup: string): void;
+    /**
+     * `gtk_label_get_text` — the text as SHOWN, with markup reduced and the mnemonic
+     * marker removed. `label` is the string as written.
+     */
+    get_text(): string;
+    /** `gtk_widget_add_css_class`. A class the label already carries is a no-op. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. A class it does not carry is a no-op. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes` — the list, without the widget's own CSS name. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
+    set_css_classes(names: readonly string[]): void;
+    private _setClasses;
+    private _render;
+}
+export {};

package/lib/types/widgets/gtk-menu-button.d.ts

@@ -1,34 +1,45 @@
-import type { AdwMenuEntry } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
 import { type EventData } from '@nativescript/core';
 import { AdwImageButton } from './adw-image-button.js';
+import { type ConstructProps } from './construct-props.js';
 /** Event name emitted when a menu item is chosen. */
 export declare const MENU_ITEM_ACTIVATED = "menuItemActivated";
-/**
- * One entry in an {@link GtkMenuButton}'s menu — `@gjsify/adwaita-core`'s
- * {@link AdwMenuEntry}, under the name this widget has always used.
- *
- * It used to be a THIRD declaration of the same shape (the browser element had a
- * second, and the core the original), and this one was missing `icon` — so a menu
- * written for one renderer was not the same object on the other. The browser side
- * adopted the core type in #1191; this is its twin.
- */
-export type AdwMenuItem = AdwMenuEntry;
 /** Payload of the {@link MENU_ITEM_ACTIVATED} event. */
 export interface MenuItemActivatedEventData extends EventData {
     /** The chosen item's id (or its label when no id was given). */
     id: string;
     /** The chosen item's label. */
     label: string;
-    /** The chosen item's index in {@link GtkMenuButton.menuItems}. */
-    index: number;
+    /**
+     * Where the item sits in {@link GtkMenuButton.menuModel} — a PATH since ADR 0042,
+     * because a submenu is a model of its own and a flat index cannot name one.
+     */
+    path: readonly number[];
+    /** The chosen item's detailed action name, when the item carried one. */
+    action?: string;
 }
 export declare class GtkMenuButton extends AdwImageButton {
-    private _items;
+    private _model;
+    private _actions;
     private _menuTitle;
-    constructor();
-    /** The menu items (opened as a native `action()` sheet on tap). */
-    get menuItems(): AdwMenuItem[];
-    set menuItems(value: AdwMenuItem[]);
+    constructor(props?: ConstructProps<GtkMenuButton>);
+    /**
+     * The menu, normalised (ADR 0042) — opened as a native `action()` sheet on tap.
+     *
+     * Accepts every input form the portable model does, a bare `string[]` included —
+     * but NOT a JSON string; see `AdwSplitButton.menuModel` for why the XML door stays
+     * shut until a probe can prove it, and why being shut is not the same as being
+     * silent.
+     */
+    get menuModel(): AdwMenuModel;
+    set menuModel(value: AdwMenuInput);
+    /**
+     * What the action group publishes about the actions this menu names — the portable
+     * stand-in for a `GActionGroup`, and the only source of a menu's enabled/checked
+     * state (ADR 0042).
+     */
+    get actions(): AdwMenuActions | null;
+    set actions(value: AdwMenuActions | null);
     /** Optional title shown atop the native menu sheet. */
     get menuTitle(): string;
     set menuTitle(value: string);

package/lib/types/widgets/icon-theme.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The name every unresolvable name resolves TO.
+ *
+ * libadwaita's own answer, and `adwaita-web`'s: a name nothing can draw draws the
+ * broken-image glyph rather than nothing at all. An empty icon is invisible, and an
+ * invisible failure is the class `check-adwaita-icon-masks.mjs` exists to have ended
+ * once already — there a missing mask painted a solid 16px square that read as a
+ * deliberate swatch, and no test could see it.
+ */
+export declare const ICON_FALLBACK_NAME = "image-missing";
+/**
+ * What a caller's icon value IS.
+ *
+ * `'empty'` is not the same answer as `'name'` that fails to resolve: the widgets read
+ * it as "no icon" and take their own absent-icon path (an avatar falls back to the
+ * person glyph, a status page collapses the image), which is libadwaita's behaviour for
+ * a NULL `icon-name` and must not become an `image-missing`.
+ */
+export type IconValueKind = 'empty' | 'name' | 'source';
+/**
+ * Which of the two doors a value came through — the whole discrimination, in one place.
+ *
+ * An SVG document is recognised by its FIRST non-space character being `<`, which admits
+ * an XML prolog and a DOCTYPE ahead of the root element (both legitimate in an icon read
+ * off a file, and `icon-registry.ts` on the web side takes the same two). An icon name is
+ * whatever `normalizeIconName` accepts: one CSS token once an optional `-symbolic` comes
+ * off. Nothing is both, so nothing has to be guessed.
+ *
+ * A value that is NEITHER — `'two words'`, `'org.gnome.Builder'` — is reported as a
+ * `'name'`, because that is what the caller meant and resolution draws
+ * {@link ICON_FALLBACK_NAME} for it. Calling it a source instead would hand an
+ * un-parseable string to the rasteriser, which draws nothing and says nothing.
+ */
+export declare function iconValueKind(value: string | null | undefined): IconValueKind;
+/** Whether {@link resolveIconSource} can draw `name` without falling back. */
+export declare function isIconAvailable(name: string | null | undefined): boolean;
+/** The subset's names, sorted — for a spec or a gate that has to enumerate them. */
+export declare function compiledIconNames(): string[];
+/** The names {@link registerIcon} has added, sorted. */
+export declare function registeredIconNames(): string[];
+/**
+ * Make `name` resolvable from an Adwaita symbolic SVG source (what
+ * `@gjsify/adwaita-icons` exports), for a glyph the compiled subset does not carry.
+ *
+ *     import { registerIcon } from '@gjsify/adwaita-nativescript';
+ *     import { dialogErrorSymbolic } from '@gjsify/adwaita-icons/status';
+ *
+ *     registerIcon('dialog-error-symbolic', dialogErrorSymbolic);
+ *     // …then anywhere: new Adw.StatusPage({ iconName: 'dialog-error-symbolic' })
+ *
+ * BOTH arguments are checked and a wrong one THROWS, the same verdict the web registry
+ * reaches for the same reason: this is an explicit call, and quietly registering
+ * something undrawable produces an icon strictly WORSE than an unregistered one — it
+ * beats the `image-missing` fallback and draws nothing, while {@link isIconAvailable}
+ * reports `true`.
+ *
+ * The SVG test is LEXICAL, not a parse, and that is a real limit rather than a shortcut:
+ * NativeScript has no `DOMParser`, and the rasterisers here read the document with
+ * `extractIconPaths`' own scanner. So a well-formed document with no `<svg>` root is
+ * refused, and a malformed one inside an `<svg>` is accepted and draws whatever
+ * `extractIconPaths` finds in it — which is the same thing it would have drawn had the
+ * caller passed it straight to the widget.
+ *
+ * Registering a name the subset already compiles REPLACES the glyph.
+ */
+export declare function registerIcon(name: string, svg: string): void;
+/** Drop a registration, so the name falls back to the compiled subset. Test seam. */
+export declare function unregisterIcon(name: string): boolean;
+/**
+ * A caller's icon value as the SVG document a rasteriser can read.
+ *
+ * The one function every icon property on this port goes through, so that a name means
+ * the same thing on all of them. `''` stays `''` — see {@link IconValueKind}. A source
+ * passes through untouched. A name resolves against the registrations, then the compiled
+ * subset, then {@link ICON_FALLBACK_NAME}.
+ */
+export declare function resolveIconSource(value: string | null | undefined): string;

package/lib/types/widgets/icons.d.ts

@@ -3,7 +3,9 @@ import type { SymbolicIconOptions } from './icon-path.js';
 export { ADWAITA_ICON_GRID, DEFAULT_ICON_COLOR, DEFAULT_ICON_COLOR_DARK, extractIconPaths, extractPathData, } from './icon-path.js';
 export type { IconPath, SymbolicIconOptions } from './icon-path.js';
 /**
- * Render an Adwaita symbolic SVG string to a native {@link ImageSource}. The base
+ * Render an Adwaita symbolic SVG string to a native {@link ImageSource}. A NAME is not
+ * accepted here — `resolveIconSource` in `icon-theme.ts` turns one into the document
+ * first, so the rasteriser has exactly one input shape. The base
  * implementation returns `null` — only the platform variants rasterise. Callers
  * treat `null` as "no icon available" (the widget shows nothing / its fallback).
  */

package/lib/types/widgets/index.d.ts

@@ -18,14 +18,22 @@ export { AdwSliderRow, NOTIFY_SLIDER_VALUE } from './adw-slider-row.js';
 export type { NotifySliderValueEventData } from './adw-slider-row.js';
 export { AdwExpanderRow, ExpanderState, NOTIFY_EXPANDED } from './adw-expander-row.js';
 export type { ExpanderStateListener, NotifyExpandedEventData } from './adw-expander-row.js';
-export { GtkButton } from './gtk-button.js';
-export type { AdwButtonVariant } from './gtk-button.js';
+export { GtkButton, GTK_BUTTON_CLICKED, GTK_BUTTON_LABEL_CLASS } from './gtk-button.js';
+export { buttonSlotAfterWrite, buttonSlotDetaches } from './button-slot.js';
+export type { ButtonSlot, ButtonSlotWrite } from './button-slot.js';
+export { GtkBox, DEFAULT_BOX_SPACING } from './gtk-box.js';
+export { boxChildMargin, boxSpacingChanges, normalizeBoxSpacing } from './box-layout.js';
+export type { BoxOrientation } from './box-layout.js';
+export { GtkLabel } from './gtk-label.js';
+export { labelDisplayText, labelMarkupIsUnparseable } from './label-text.js';
 export { AdwImageButton, DEFAULT_ICON_BUTTON_ICON_SIZE } from './adw-image-button.js';
 export { GtkMenuButton, MENU_ITEM_ACTIVATED } from './gtk-menu-button.js';
-export type { AdwMenuItem, MenuItemActivatedEventData } from './gtk-menu-button.js';
-export { AdwIcon, DEFAULT_ADW_ICON_SIZE } from './adw-icon.js';
+export type { MenuItemActivatedEventData } from './gtk-menu-button.js';
+export { MENU_CANCEL_LABEL, menuSheetActions, menuSheetRows, presentMenuSheet, resolveMenuChoice, } from './menu-sheet.js';
+export type { MenuSheetPresenter, MenuSheetRow } from './menu-sheet.js';
+export { GtkImage, DEFAULT_GTK_IMAGE_SIZE } from './gtk-image.js';
 export { AdwBanner, BUTTON_CLICKED } from './adw-banner.js';
-export { AdwAvatar, DEFAULT_AVATAR_SIZE, avatarInitials } from './adw-avatar.js';
+export { AVATAR_DEFAULT_ICON, AdwAvatar, DEFAULT_AVATAR_SIZE, avatarInitials } from './adw-avatar.js';
 export { AdwWindowTitle } from './adw-window-title.js';
 export { AdwClamp, DEFAULT_CLAMP_MAX_SIZE } from './adw-clamp.js';
 export { AdwHeaderBar } from './adw-header-bar.js';
@@ -83,6 +91,11 @@ export type { AdwAlertResponse, AdwResponseAppearance, AdwResponseOptions, Notif
 export { AdwAboutDialog, CLOSED as ABOUT_CLOSED } from './adw-about-dialog.js';
 export { AdwPreferencesDialog, CLOSED as PREFERENCES_CLOSED } from './adw-preferences-dialog.js';
 export { attachRowPressFeedback } from './row-press.js';
+export { applyConstructProps, nsAlignment } from './construct-props.js';
+export type { ConstructProps } from './construct-props.js';
+export { GTK_ALIGN } from './gtk-align.js';
+export { ICON_FALLBACK_NAME, compiledIconNames, iconValueKind, isIconAvailable, registerIcon, registeredIconNames, resolveIconSource, unregisterIcon, } from './icon-theme.js';
+export type { IconValueKind } from './icon-theme.js';
 export { ADWAITA_ICON_GRID, DEFAULT_ICON_COLOR, DEFAULT_ICON_COLOR_DARK, extractIconPaths, extractPathData, renderSymbolicIcon, } from './icons.js';
 export type { IconPath, SymbolicIconOptions } from './icons.js';
 export { adwaitaColorScheme, isThemeIconColor, onAdwaitaColorSchemeChanged, setAdwaitaColorScheme, themeIconColor, toggleAdwaitaColorScheme, } from './color-scheme.js';