@gjsify/adwaita-nativescript 0.48.0 → 0.50.0

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

@@ -1,6 +1,7 @@
 import { Label, StackLayout, type EventData } from '@nativescript/core';
 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,7 +13,18 @@ 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. */
@@ -21,7 +33,7 @@ export declare class GtkDropDown extends StackLayout {
     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 list model (`Gtk.DropDown:model`). Updates the button label. */
@@ -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-icon-size.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Every `Gtk.IconSize` member, in GIR declaration order.
+ *
+ * Held against `GtkIconSizeNick` in `packages/framework/gtk-host/src/generated/props.ts` by
+ * arm 7 of `scripts/check-nativescript-xml-doors.mjs` — in-repo, GIR-derived, emitted by a
+ * generator that has never heard of this port — so this array is a copy that cannot drift
+ * rather than a second source. No member is an alias, so unlike `Gtk.Align` the positions
+ * ARE the values.
+ */
+export declare const GTK_ICON_SIZE_NICKS: readonly ["inherit", "normal", "large"];
+/** One of the three `Gtk.IconSize` members, spelled as its nick. */
+export type GtkIconSizeNick = (typeof GTK_ICON_SIZE_NICKS)[number];
+/**
+ * What each member renders at, in DIPs — the measurement in this file's header.
+ *
+ * `inherit` means "take the size from the context" on GTK, where a parent's
+ * `-gtk-icon-size` cascades. NativeScript has no such cascade — an `Image` is sized by its
+ * own `width`/`height` and nothing inherits one — so there is nothing here to inherit FROM,
+ * and the honest reading of `inherit` is the size GTK itself falls back to when no ancestor
+ * sets one, which the measurement puts at 16. That it equals `normal` is not a coincidence
+ * to be tidied away: the two agree on GTK too, and they would stop agreeing the day this
+ * port grows a context that carries a size.
+ */
+export declare const GTK_ICON_SIZE_PIXELS: Readonly<Record<GtkIconSizeNick, number>>;
+/** The size an icon draws at when neither property was set — the Adwaita 16px symbolic grid. */
+export declare const DEFAULT_ICON_PIXEL_SIZE: number;
+/**
+ * Every `Gtk.IconSize` member, nick to constant.
+ *
+ * The positions ARE the values here, and that is a fact about THIS enum rather than a
+ * shortcut: no member of `Gtk.IconSize` is an alias, so nothing shifts below anything.
+ * `Gtk.Align` is the counter-example the sibling file is built around — `GTK_ALIGN_BASELINE`
+ * was deprecated into an alias in GTK 4.12, so 2 of its 7 members are not their position —
+ * which is why this is DERIVED from the nick order and then held against the committed,
+ * typelib-read `ENUM_VALUES` in `packages/framework/gtk-host/src/generated/enum-values.mts`
+ * by arm 7 of `check-nativescript-xml-doors.mjs`. A derivation that happens to be right is
+ * worth nothing without the oracle beside it.
+ */
+export declare const GTK_ICON_SIZE: Readonly<Record<GtkIconSizeNick, number>>;
+/** Is `value` one of the three members? */
+export declare function isGtkIconSizeNick(value: unknown): value is GtkIconSizeNick;
+/**
+ * A `Gtk.IconSize` value as its NICK — the nick itself, or the constant a GJS caller's
+ * `Gtk.IconSize.LARGE` is.
+ *
+ * A NON-NUMBER goes back unchanged, for the SETTER to refuse with the one message that names
+ * the three members — one refusal, not two. A number that is no member is refused HERE
+ * instead, and the two are not the same mistake: by writing a number the caller has said
+ * "constant", so the setter could only report it as a bad nick, where `24` is a size in DIPs
+ * written under the wrong name and the throw can say exactly that.
+ *
+ * ADR 0034 § 4's second spelling, and it lives HERE rather than in the setter on purpose: a
+ * setter that widened its declared type to admit the constant would drag the number into the
+ * XML ATTRIBUTE door, which has no coercer. The construct-props bag is the one door that
+ * carries a real JS value, so it is the one that coerces — the arrangement `Gtk.Align`
+ * already has in `construct-props.ts`.
+ */
+export declare function iconSizeNickOf(value: unknown): unknown;
+/**
+ * `value` as a `Gtk.IconSize` member, or a THROW naming what it was and what is accepted.
+ *
+ * The one setter in this package that refuses rather than falling back, and the reason is
+ * the defect it replaces: a number setter fed `'large'` substituted its default, so a typo,
+ * a value copied out of the GTK documentation and a deliberate choice all produced the same
+ * silent 16 DIPs. There are exactly three legal values and no range to be lenient about, so
+ * "not one of them" is a caller mistake and nothing else — the same reasoning
+ * `parseWidgetSelector`'s empty-selector refusal follows, and the opposite of `xmlNumber`,
+ * which is lenient because a number genuinely has a sensible default.
+ *
+ * `fallback` is NAMED IN THE MESSAGE and never returned — this throws. The widget's current
+ * setting survives because nothing was assigned to it, not because of this parameter; the
+ * parameter is there so the error can say which setting that is.
+ */
+export declare function gtkIconSizeNick(value: unknown, fallback: GtkIconSizeNick): GtkIconSizeNick;
+/**
+ * GTK's "`pixel-size` is not set" sentinel — what `gtk_image_get_pixel_size` answers when
+ * the icon size is in charge.
+ *
+ * A sentinel rather than `null` because it is the value the PROPERTY carries: a getter that
+ * answered the size the image happens to draw at would make `image.pixelSize =
+ * image.pixelSize` PIN that size, and the setter falls back to the getter (every number
+ * setter in this package does — `xmlNumber(raw, this.<prop>)`), so an unparseable
+ * assignment would pin it too.
+ */
+export declare const PIXEL_SIZE_UNSET = -1;
+/** An assignment to `pixel-size` as the value to store: a positive size, or the sentinel. */
+export declare function storedPixelSize(value: number): number;
+/**
+ * The size to draw at, in DIPs: the explicit `pixelSize` when there is one, else what
+ * `iconSize` resolves to.
+ *
+ * That precedence is `Gtk.Image`'s own — `gtk_image_set_pixel_size` documents -1 as "unset,
+ * the icon size decides" and any other value as an override. Any non-positive or non-finite
+ * value reads as unset here, because a 0-DIP image is not a rendering anyone asked for.
+ */
+export declare function iconPixelSize(iconSize: GtkIconSizeNick, pixelSize: number): number;

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

@@ -1,25 +1,76 @@
 import { Image } from '@nativescript/core';
-/** Default decorative-icon size, in DIPs — the Adwaita 16px symbolic grid. */
-export declare const DEFAULT_GTK_IMAGE_SIZE = 16;
-export declare class GtkImage extends Image {
-    private _iconSvg;
+import { type GtkIconSizeNick } from './gtk-icon-size.js';
+import { type ConstructProps } from './construct-props.js';
+/**
+ * The size this image draws at when neither size property was set, in DIPs — the Adwaita
+ * 16px symbolic grid.
+ *
+ * PUBLISHED NAME, kept pointing at {@link DEFAULT_ICON_PIXEL_SIZE} rather than renamed:
+ * it predates #1584's split and means what it always meant, a NUMBER of DIPs. Read it as
+ * `pixelSize`'s default; `iconSize` now defaults to the nick `'inherit'`, which resolves
+ * to this same number.
+ */
+export declare const DEFAULT_GTK_IMAGE_SIZE: number;
+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 _pixelSize;
     private _unsubScheme;
-    constructor();
+    constructor(props?: ConstructProps<GtkImage>);
     /** Adopt the active scheme's default fill (no-op if the caller pinned a colour). */
     private _syncThemeColor;
+    /** The size this image draws at right now: `pixelSize` when set, else `iconSize`. */
+    private get _renderedSize();
+    /** Resize the image box and re-rasterise the glyph into it. */
+    private _applySize;
     private _render;
-    /** The Adwaita symbolic SVG string to render (e.g. `panDownSymbolic`). */
+    /**
+     * 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(svg: 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);
+    /**
+     * `Gtk.Image:icon-size` — one of `inherit`, `normal` (16 DIPs) or `large` (32).
+     *
+     * THE ENUM, not a number, and that is the whole of #1584: this name used to take a
+     * count of DIPs, so `<gtk:Image iconSize="large" />` — which is what a reader of the
+     * GTK documentation writes — failed to parse, fell back, and rendered at 16 with
+     * nothing reported. For a size in DIPs use {@link pixelSize}, which is the GTK
+     * property that means one. A value that is not a member THROWS, naming it and the
+     * three that are accepted: there is no range here to be lenient about.
+     */
+    get iconSize(): GtkIconSizeNick;
+    set iconSize(value: GtkIconSizeNick);
+    /**
+     * `Gtk.Image:pixel-size` — the edge length in DIPs, overriding {@link iconSize}.
+     *
+     * This is what the property called `iconSize` did before #1584, under the name GTK
+     * gives it. It reads back `-1` while unset, which is what `gtk_image_get_pixel_size`
+     * answers and NOT the size the image draws at: a getter that answered the drawn size
+     * would make `image.pixelSize = image.pixelSize` pin it. Assigning any non-positive
+     * value clears the override and hands the size back to {@link iconSize}.
+     */
+    get pixelSize(): number;
+    set pixelSize(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,6 +1,7 @@
 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";
 /** Payload of the {@link MENU_ITEM_ACTIVATED} event. */
@@ -21,7 +22,7 @@ export declare class GtkMenuButton extends AdwImageButton {
     private _model;
     private _actions;
     private _menuTitle;
-    constructor();
+    constructor(props?: ConstructProps<GtkMenuButton>);
     /**
      * The menu, normalised (ADR 0042) — opened as a native `action()` sheet on tap.
      *

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,8 +18,14 @@ 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 { MenuItemActivatedEventData } from './gtk-menu-button.js';
@@ -27,7 +33,7 @@ export { MENU_CANCEL_LABEL, menuSheetActions, menuSheetRows, presentMenuSheet, r
 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';
@@ -85,6 +91,12 @@ 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 { DEFAULT_ICON_PIXEL_SIZE, GTK_ICON_SIZE_NICKS, GTK_ICON_SIZE_PIXELS, type GtkIconSizeNick, isGtkIconSizeNick, PIXEL_SIZE_UNSET, } from './gtk-icon-size.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';

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

@@ -0,0 +1,13 @@
+/**
+ * The string a `Gtk.Label` puts in `Label.text` for a given `label` and the two flags
+ * that transform it.
+ *
+ * ORDER MATTERS AND FOLLOWS THE C: markup is reduced first, the mnemonic marker second.
+ * `gtk_label_set_markup_with_mnemonic` parses the markup and then takes the underscore out
+ * of the resulting TEXT, so an `_` inside a tag's attributes is not a mnemonic. Doing it
+ * the other way round would let `<span font_desc="Sans">` lose its underscore and stop
+ * parsing.
+ */
+export declare function labelDisplayText(label: string, useMarkup: boolean, useUnderline: boolean): string;
+/** Whether `label` carries markup this port could not reduce, so the raw string is shown. */
+export declare function labelMarkupIsUnparseable(label: string, useMarkup: boolean): boolean;

package/lib/types/widgets/row-state.d.ts

@@ -37,7 +37,7 @@ export interface NsButtonRowIconVisuals {
  * title through a second state object would give one label two sources of truth.
  * {@link rowLabelVisuals} paints it.
  *
- * The icon payload is the symbolic SVG SOURCE, not GTK's icon name, because `GtkImage`
+ * The icon payload is whatever the caller set — a name or the symbolic SVG source, because `GtkImage`
  * renders SVG rather than resolving a name. `ButtonRowState` is indifferent: its rule
  * is `string_is_not_empty`, which reads the first byte.
  */

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

@@ -0,0 +1,40 @@
+import type { EventData, Observable } from '@nativescript/core';
+/** The two methods the mixin adds. Named so a consumer can annotate with it. */
+export interface GObjectSignals {
+    /**
+     * Subscribe to `eventName` — a NativeScript event, or one of the `notify::<prop>`
+     * events this port's widgets emit — and get back the id that `disconnect` takes.
+     *
+     * The callback receives the emitting widget FIRST, as a GJS signal handler does,
+     * then the NativeScript payload.
+     */
+    connect(eventName: string, callback: (self: this, data: EventData) => void): number;
+    /** Remove exactly the handler `connect` returned this id for. Throws on an id nothing holds. */
+    disconnect(handlerId: number): void;
+}
+/**
+ * A constructor the mixin can wrap: anything that is an `Observable`, abstract or not.
+ *
+ * `any[]` and not `unknown[]`: TypeScript accepts a mixin base only as a constructor with a
+ * single rest parameter of type `any[]` (TS2545), so the wider spelling is the one the
+ * language requires here rather than a shortcut.
+ */
+export type ObservableConstructor = abstract new (...args: any[]) => Observable;
+/**
+ * Give a `@nativescript/core` base GJS's `connect` / `disconnect`.
+ *
+ * Applied ONCE per class that extends a platform base — `extends withSignals(GridLayout)`
+ * — and never on a class whose base is already a widget of this package, which inherits
+ * the two methods and would otherwise carry a second, identical copy one prototype up.
+ */
+export declare function withSignals<TBase extends ObservableConstructor>(Base: TBase): (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;
+}) & TBase;

package/lib/types/widgets/split-view-base.d.ts

@@ -10,7 +10,18 @@ export interface NotifyShowSidebarEventData extends EventData {
     /** Whether the view is in its collapsed (narrow) mode. */
     collapsed: boolean;
 }
-export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState = NsSplitViewState> extends GridLayout {
+declare const AdwSplitViewBase_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 abstract class AdwSplitViewBase<TState extends NsSplitViewState = NsSplitViewState> extends AdwSplitViewBase_base {
     /** Which widget's width rule applies — they differ once a pane has a minimum. */
     protected readonly _widthRule: SplitViewWidthRule;
     /** The headless state machine this widget renders (`split-view-state.ts`). */
@@ -20,7 +31,7 @@ export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState =
     /** The three width PROPERTIES; the drawn width is derived from them. */
     protected _widthProps: SidebarWidthProps;
     /** The container width the sidebar was last sized against, in DIPs. */
-    protected _measuredWidth: number;
+    protected _splitWidth: number;
     /** An explicit `sidebarWidth` assignment, which overrides the derivation. */
     protected _sidebarWidthOverride: number | null;
     constructor(rootClass: string, 
@@ -74,10 +85,10 @@ export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState =
     protected _cancelPending(): void;
     /** Whether `view` is currently a child of this layout. */
     protected _isChild(view: View): boolean;
-    /** Set (or replace) the sidebar pane. */
-    setSidebar(view: View | null): void;
-    /** Set (or replace) the content pane. */
-    setContent(view: View | null): void;
+    /** Set (or replace) the sidebar pane — `set_sidebar` on both split views. */
+    set_sidebar(view: View | null): void;
+    /** Set (or replace) the content pane — `set_content` on both split views. */
+    set_content(view: View | null): void;
     /**
      * An XML child asks for `sidebar` or `content`, and a bare one is CONTENT.
      *
@@ -135,3 +146,4 @@ export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState =
     /** The content pane, or `null`. */
     get content(): View | null;
 }
+export {};

package/lib/types/widgets/status-page-content.d.ts

@@ -10,7 +10,7 @@ export declare function statusPageLabelVisibility(text: string | null | undefine
  * `has_image`, bound to the image's `visible`.
  *
  * C is `paintable || (icon_name && icon_name[0])`; this port has no `paintable`
- * counterpart (the icon is an SVG string handed to `GtkImage`), so only the second
+ * counterpart (the icon is a name or an SVG string handed to `GtkImage`), so only the second
  * half applies. Kept as its own predicate rather than folded into
  * {@link statusPageLabelVisibility} because upstream really are two closures, and
  * the missing half is a real gap rather than a simplification.