@gjsify/adwaita-nativescript 0.48.0 → 0.49.0

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

@@ -1,19 +1,35 @@
 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;
-export declare class GtkImage extends Image {
-    private _iconSvg;
+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();
+    constructor(props?: ConstructProps<GtkImage>);
     /** Adopt the active scheme's default fill (no-op if the caller pinned a colour). */
     private _syncThemeColor;
     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. */
@@ -23,3 +39,4 @@ export declare class GtkImage extends Image {
     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,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,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';

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.

package/lib/types/widgets/style-classes.d.ts

@@ -0,0 +1,61 @@
+/**
+ * What a `styleClasses` write means here.
+ *
+ * THE DOOR TAKES A STRING AND THE READ-BACK IS A LIST, which is the DOM's own
+ * `className`/`classList` split and not a compromise: the two places that WRITE this are a
+ * NativeScript XML attribute and `View.className`, and both are strings, while
+ * `GtkWidget:css-classes` holds a list and so does the getter. An array-taking door would
+ * need a fourth attribute kind in `check-generated-website-data` — it has `number`,
+ * `boolean` and `json`, and `json` there means "parses to a plain OBJECT", so not even
+ * `'["pill"]'` reaches it — and inventing one to offer a second spelling of a door that
+ * already works is the "second way to say what the table can already say" that gate's own
+ * header refuses.
+ *
+ * NO ARRAY ARM. It had one, "because the widget's internals rebuild the list through it";
+ * the internals are the two setters and both are typed `string | null | undefined`, so the
+ * arm was unreachable and its `String(name)` coercion guarded nothing.
+ */
+export type AdwStyleClassesInput = string | null | undefined;
+/**
+ * The class list a `styleClasses` write means: split on whitespace, trimmed,
+ * de-duplicated, order preserved.
+ *
+ * A STRING IS THE XML DOOR. NativeScript's `setPropertyValue` ends in `instance[name] =
+ * value`, so `<gtk:Button styleClasses="pill suggested-action">` hands the setter that
+ * whole string — the same fact `xmlNumber`/`xmlBoolean` exist for, one type over.
+ */
+export declare function normalizeStyleClasses(value: AdwStyleClassesInput): string[];
+/**
+ * `className` for a widget whose own class is `base` and which carries `classes`.
+ *
+ * AN EMPTY `base` IS A WIDGET WITH NO CLASS OF ITS OWN, and two of them ship: `Gtk.Box`
+ * and `Gtk.Label` are transparent — there is no Adwaita fill, radius or typography to give
+ * a box or a bare label, so they carry only what a caller puts on them. The empties are
+ * filtered rather than joined, because `` `${''} ${'title-1'}` `` is a leading space and
+ * NativeScript's `className` splitter turns that into an empty class name.
+ */
+export declare function classNameWith(base: string, classes: readonly string[]): string;
+/**
+ * The list after `gtk_widget_add_css_class(name)` — GTK's own method, and the door a GJS
+ * snippet reaches for.
+ *
+ * WHY THE METHODS EXIST BESIDE THE `styleClasses` PROPERTY. A NativeScript XML attribute
+ * can only carry a string, which is what `styleClasses` is for; a TypeScript caller ported
+ * off GJS writes `button.add_css_class('pill')`, and that line is in every Adwaita snippet
+ * that gives a button a look. The two doors hold the SAME list, so a widget that offers
+ * both cannot have them disagree — which is why the mutation is a pure function over the
+ * list rather than a second `className` rewrite per method.
+ *
+ * ADDS AT THE END, AND ONLY IF ABSENT. `gtk_widget_add_css_class` is a no-op for a class
+ * the widget already has (the quark is already in the list), so a second add does not move
+ * it — measured under gjs 1.88.1: `add_css_class('a'); add_css_class('b');
+ * add_css_class('a')` reads back two classes.
+ *
+ * ONE NAME, TRIMMED. GTK takes a single class name and would happily intern `'a b'` as one
+ * unmatchable class; here the string door already means "a whitespace-separated list", so a
+ * name with whitespace in it is the caller confusing the two doors. It is trimmed, and an
+ * empty name is dropped rather than added as a class nothing can be.
+ */
+export declare function withCssClass(classes: readonly string[], name: string): string[];
+/** The list after `gtk_widget_remove_css_class(name)`. Absent is a no-op, as in C. */
+export declare function withoutCssClass(classes: readonly string[], name: string): string[];

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

@@ -11,11 +11,22 @@ export declare const NOTIFY_SELECTED = "notify::selected";
  */
 export interface NotifyViewSelectedEventData extends EventData, ViewSwitcherNotifyPayload {
 }
+declare const AdwViewSwitcherBase_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;
 /**
  * Shared base: a switcher bar (row 0) + a content area (row 1), one page visible.
  * Subclasses set the bar/button CSS classes for their look.
  */
-export declare abstract class AdwViewSwitcherBase extends GridLayout {
+export declare abstract class AdwViewSwitcherBase extends AdwViewSwitcherBase_base {
     /** The horizontal switcher bar holding the buttons. */
     protected readonly _bar: GridLayout;
     /** `Adw.ViewSwitcher:policy`, default NARROW as in C. */

package/lib/types/widgets/view-switcher-model.d.ts

@@ -10,7 +10,7 @@ import type { AdwViewSwitcherPageInit, ViewSwitcherStateChange } from '@gjsify/a
  *
  * `icon` is an Adwaita symbolic SVG DOCUMENT here, not a GTK icon name: `GtkImage`
  * rasterises the path data natively. The core treats the field as an opaque
- * handle and only ever interprets "absent or empty"; {@link nsIconSvg} resolves
+ * handle and only ever interprets "absent or empty"; `icon-theme.ts` resolves
  * the fallback sentinel it hands back.
  */
 export interface AdwViewPage {
@@ -18,7 +18,7 @@ export interface AdwViewPage {
     title?: string;
     /** The page content view, shown when this page is selected. */
     content: View;
-    /** Adwaita symbolic SVG shown on the switcher button; absent means none. */
+    /** The icon shown on the switcher button — a NAME or SVG source; absent means none. */
     icon?: string;
     /** Stable id used by `visible-child-name`; defaults to the page's position. */
     name?: string;
@@ -47,15 +47,6 @@ export declare function createViewSwitcherBarState(): ViewSwitcherBarState;
 export declare function viewSwitcherPageSpec(page: AdwViewPage, index: number): AdwViewSwitcherPageInit;
 /** {@link viewSwitcherPageSpec} over a whole page list. */
 export declare function viewSwitcherPageSpecs(pages: readonly AdwViewPage[]): AdwViewSwitcherPageInit[];
-/**
- * Resolve the core's icon slot to something `GtkImage` can rasterise.
- *
- * The core substitutes the NAME `image-missing` for an absent icon. On the browser
- * side that name becomes a CSS mask class; here it has to become the actual
- * symbolic document, so the sentinel is swapped for the vendored
- * `image-missing-symbolic` SVG. Anything else is already an SVG and passes through.
- */
-export declare function nsIconSvg(iconName: string): string;
 /**
  * The `visibility` each page's content view must carry for the current
  * selection, in page order. Exactly one entry is `'visible'` — none when nothing

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-nativescript",
-    "version": "0.48.0",
+    "version": "0.49.0",
     "description": "Native Adwaita widgets for the NativeScript runtime — real NativeScript components (StackLayout/GridLayout/Switch/Label) styled like Libadwaita, not a webview",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -51,10 +51,10 @@
         "design-system"
     ],
     "dependencies": {
-        "@gjsify/adwaita-core": "^0.48.0",
-        "@gjsify/adwaita-fonts": "^0.48.0",
-        "@gjsify/adwaita-icons": "^0.48.0",
-        "@gjsify/native-platform": "^0.48.0"
+        "@gjsify/adwaita-core": "^0.49.0",
+        "@gjsify/adwaita-fonts": "^0.49.0",
+        "@gjsify/adwaita-icons": "^0.49.0",
+        "@gjsify/native-platform": "^0.49.0"
     },
     "peerDependencies": {
         "@nativescript/core": "*"
@@ -65,8 +65,8 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.48.0",
-        "@gjsify/unit": "^0.48.0",
+        "@gjsify/cli": "^0.49.0",
+        "@gjsify/unit": "^0.49.0",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },

package/src/theme/adwaita.css

@@ -499,6 +499,49 @@ Page.adw-window {
     padding: 10 32 10 32;
 }
 
+/* `%circular_button` — the explicit exception to the 9px rounded square: a full
+ * circle at 34×34 with no padding (_buttons.scss:312-317). It is the shape an
+ * icon-only button takes, which is why the rule arrives with the icon: while
+ * `Gtk.Button` was the platform's text-only `Button` the variant "had no counterpart
+ * at all", and a class with no rule would have drawn a rounded rectangle instead. The
+ * 34 is the same number `.adw-image-button` above carries, from the same line. */
+.adw-button.circular {
+    width: 34;
+    height: 34;
+    border-radius: 9999;
+    padding: 0;
+}
+
+/* The button's OWN label, and it exists because the button is a `GridLayout`.
+ *
+ * `.adw-button` above declares `color` and `font-weight`; a `GridLayout` has no text,
+ * so neither reaches anything and the label would render at the platform default —
+ * silently, since a wrong font is not an error. `.adw-button-content-label` next to it
+ * had to exist for the same reason, and these are the same numbers: the 15pt / 700 of
+ * libadwaita's `button { font-weight: bold }` (_buttons.scss:1) over the label colour
+ * `.adw-button` carries.
+ *
+ * NOT MERGED WITH `.adw-button-content-label`: that class is `Adw.ButtonContent`'s and
+ * comes with the icon's 6 right-margin and the content's own padding rule; a plain
+ * text button has neither, and one selector for both would give every text button
+ * `image-text-button` spacing. */
+.adw-button-label {
+    font-size: 15;
+    font-weight: 700;
+    color: rgba(0, 0, 0, 0.8);
+}
+
+/* On a suggested/destructive button the label takes the button's intent colour — the
+ * explicit label colour above would otherwise win over the inherited one, which is the
+ * same override `.adw-button-content-label` needs two blocks down. */
+.adw-button.suggested-action .adw-button-label {
+    color: #ffffff;
+}
+
+.adw-button.destructive-action .adw-button-label {
+    color: #c01c28;
+}
+
 /* Pressed (`:highlighted`) — Adwaita darkens the button on press rather than
  * showing a Material ripple. Mirrors adwaita-web's `:active` shades
  * (`--button-active-color` / darker `--accent-color`). Pill inherits the base. */
@@ -1740,6 +1783,21 @@ Page.ns-dark.adw-window {
     color: #ffffff;
 }
 
+/* Dark: the button's own label. Same three colours the dark `.adw-button` rules
+ * carry — near-white on the plain and flat button, white on suggested, the dark
+ * destructive red. */
+.ns-dark .adw-button-label {
+    color: #ffffff;
+}
+
+.ns-dark .adw-button.suggested-action .adw-button-label {
+    color: #ffffff;
+}
+
+.ns-dark .adw-button.destructive-action .adw-button-label {
+    color: #ff7b80;
+}
+
 /* Dark pressed (`:highlighted`) — Adwaita's lighter-overlay press shade. */
 .ns-dark .adw-button:highlighted {
     background-color: rgba(255, 255, 255, 0.22);