@gjsify/adwaita-core 0.51.1 → 0.52.0

package/lib/types/dialog.d.ts

@@ -152,6 +152,127 @@ export interface BottomSheetCloseState {
  * Neither can fire on a closed sheet, so neither signals anything.
  */
 export declare function resolveBottomSheetClose(source: BottomSheetCloseSource, state: BottomSheetCloseState): BottomSheetCloseOutcome;
+/**
+ * Which affordance asked a bottom sheet to OPEN.
+ *
+ * libadwaita gives a user exactly ONE surface to open a sheet from — the bottom bar. Both
+ * doors into it are gated by `can-open`, and both are unreachable without a bar:
+ *
+ * - `'bottom-bar'`  — a click on the bar. The bin IS a `GtkButton`
+ *                     (adw-bottom-sheet.c:1203) whose own click gesture is put in
+ *                     `GTK_PHASE_NONE` by `disable_button_click` (:1209), so a pointer press
+ *                     runs `bottom_bar_released_cb` (:263-284) and a keyboard activation
+ *                     runs `bottom_bar_clicked_cb` (:402-407). Same verdict from both.
+ * - `'swipe'`       — an upward swipe off the bar (`prepare_cb`, :1052-1053).
+ * - `'drag-handle'` — the pill, decorative exactly as in the dismissal gate.
+ */
+export type BottomSheetOpenSource = 'bottom-bar' | 'swipe' | 'drag-handle';
+/**
+ * What a renderer must do about an open request. There is no `'open-attempt'`: libadwaita
+ * has no signal for a refused open, so a sheet that will not open is silent.
+ */
+export type BottomSheetOpenOutcome = 'open' | 'ignored';
+/**
+ * What {@link resolveBottomSheetOpen} decides from — the SAME four properties the chrome is
+ * derived from, which is the finding rather than a convenience: whether a user can open the
+ * sheet is exactly the question of whether the bar is on screen and not inert.
+ */
+export type BottomSheetOpenState = BottomSheetChromeState;
+/**
+ * The open decision table.
+ *
+ * Only ONE of the four inputs is a branch inside a callback — `can_open`. The other three
+ * are REACHABILITY, which is why a port that reads only the callbacks gets them wrong:
+ *
+ * - no bottom bar: the stack never switches to the bin (`show_bottom_bar` returns before the
+ *   switch, adw-bottom-sheet.c:294-295; `set_bottom_bar` puts `sheet_page` back, :1615-1616),
+ *   and the swipe area is a ZERO-HEIGHT rectangle at progress 0 because `bottom_bar_height`
+ *   is 0 (`get_swipe_area`, :1412-1433). Upstream states the consequence outright — `can-open`
+ *   "does nothing if [property@BottomSheet:bottom-bar] is not set" (:2013).
+ * - already open: `set_open (TRUE)` switches the stack away from the bin (:1701-1702), so
+ *   there is nothing to click, and `prepare_cb` reads an open sheet's gesture as a CLOSE
+ *   (:1050-1051) rather than a second open.
+ * - bar not revealed: at progress 0 `reveal_animation_done_cb` makes the whole sheet bin
+ *   child-invisible (:362-364, and the same expression at :341-343), so the bar is off screen.
+ *
+ * `can_open` itself is NOT reachability: the bin stays focusable and merely gains the `inert`
+ * style class (:2033-2036), which is why {@link BottomSheetChrome.bottomBarInert} is a class
+ * to paint rather than a widget to disable.
+ */
+export declare function resolveBottomSheetOpen(source: BottomSheetOpenSource, state: BottomSheetOpenState): BottomSheetOpenOutcome;
+/** Which of the sheet bin's two stack children is showing (`sheet_stack`). */
+export type BottomSheetLayer = 'sheet' | 'bottom-bar';
+/** What {@link resolveBottomSheetChrome} decides from. */
+export interface BottomSheetChromeState {
+    /** `AdwBottomSheet:open`. */
+    open: boolean;
+    /** `AdwBottomSheet:can-open`. */
+    canOpen: boolean;
+    /** Whether `AdwBottomSheet:bottom-bar` is set. */
+    hasBottomBar: boolean;
+    /** `AdwBottomSheet:reveal-bottom-bar`; absent means revealed. */
+    revealBottomBar?: boolean;
+    /** `AdwBottomSheet:modal`; absent means modal, the pspec default (adw-bottom-sheet.c:1128). */
+    modal?: boolean;
+}
+/** What a renderer has to put on screen for a given state. */
+export interface BottomSheetChrome {
+    /** Which stack child the sheet bin shows. */
+    layer: BottomSheetLayer;
+    /** Whether the sheet bin is on screen at all (`gtk_widget_set_child_visible`). */
+    surfaceVisible: boolean;
+    /** Whether the bar carries the `inert` style class — still clickable, just refusing. */
+    bottomBarInert: boolean;
+    /**
+     * Whether the dimming layer covers the content — the scrim a click on dismisses through
+     * the `'dimming'` source. Only a MODAL sheet has one on screen.
+     */
+    dimmed: boolean;
+}
+/**
+ * The bin's resting appearance: which child shows, whether the bin is on screen, and whether
+ * the bar looks inert.
+ *
+ * RESTING is the whole simplification. In C these follow `progress` across
+ * `CHILD_SWITCH_THRESHOLD` mid-animation (`open_animation_cb`, adw-bottom-sheet.c:322-330);
+ * with no spring animation the settled progress IS `open`, so `showing_bottom_bar` reduces to
+ * `!open` — which is also its init value (:1131) for a sheet that starts closed.
+ *
+ * The dimming reduces the same way. `set_open (TRUE)` makes it child-visible exactly when the
+ * sheet is modal (:1686-1687), `set_modal` re-applies that while the sheet is not settled closed
+ * (:1981-1982), and the close animation hides it once it settles (:338-339). At rest that is
+ * `open && modal`; the opacity ramp between is the animation this model does not run.
+ */
+export declare function resolveBottomSheetChrome(state: BottomSheetChromeState): BottomSheetChrome;
+/** What {@link resolveBottomSheetSwipeTracker} decides from. */
+export interface BottomSheetSwipeTrackerState {
+    /** `AdwBottomSheet:can-open`. */
+    canOpen: boolean;
+    /** `AdwBottomSheet:can-close`. */
+    canClose: boolean;
+    /** Whether `AdwBottomSheet:bottom-bar` is set. */
+    hasBottomBar: boolean;
+    /** `AdwBottomSheet:show-drag-handle`. */
+    showDragHandle: boolean;
+}
+/** The three `AdwSwipeTracker` settings `update_swipe_tracker` writes. */
+export interface BottomSheetSwipeTrackerConfig {
+    /** Whether the tracker recognises a gesture at all. */
+    enabled: boolean;
+    /** Whether a mouse drag counts, not only touch. */
+    allowMouseDrag: boolean;
+    /** Whether the gesture may overshoot below the closed position. */
+    lowerOvershoot: boolean;
+}
+/**
+ * `update_swipe_tracker` (adw-bottom-sheet.c:450-460) as a pure function.
+ *
+ * `enabled` is the line that decides whether a bottom sheet can be opened by gesture at all:
+ * `(can_open && bottom_bar != NULL) || can_close`. The `&& bottom_bar` conjunct is why
+ * `can-open` alone buys nothing — with no bar the only live arm is `can_close`, i.e. the
+ * tracker exists solely to CLOSE.
+ */
+export declare function resolveBottomSheetSwipeTracker(state: BottomSheetSwipeTrackerState): BottomSheetSwipeTrackerConfig;
 /** One entry in a {@link BottomSheetPresentation}'s teardown callback pair. */
 export type BottomSheetTeardownCallback = 'closing' | 'closed';
 /** Subscriber for {@link BottomSheetPresentation} `open` changes. */
@@ -180,10 +301,18 @@ export interface BottomSheetPresentationOptions {
  * still be closed using [property@BottomSheet:open]"); {@link requestClose} is the INTERACTIVE
  * path that runs the gate. Keeping them apart is what lets a locked sheet still be closed by
  * its owner.
+ *
+ * The same split holds the other way round: {@link requestOpen} is the user's path and runs
+ * {@link resolveBottomSheetOpen}, so a sheet with no bottom bar cannot be opened by a user at
+ * all, while its owner's `setOpen(true)` still works.
  */
 export declare class BottomSheetPresentation {
     private _open;
     private _canClose;
+    private _canOpen;
+    private _hasBottomBar;
+    private _revealBottomBar;
+    private _modal;
     private _hasBeenOpen;
     private readonly _listeners;
     private readonly _onClosing;
@@ -201,8 +330,36 @@ export declare class BottomSheetPresentation {
      * {@link setOpen}; `has_been_open` in the C source.
      */
     get hasBeenOpen(): boolean;
+    /** Whether the user may open the sheet from its bottom bar (`AdwBottomSheet:can-open`). */
+    get canOpen(): boolean;
+    /** Whether a bottom bar is set (`AdwBottomSheet:bottom-bar` is non-NULL). */
+    get hasBottomBar(): boolean;
+    /** Whether the bottom bar is revealed (`AdwBottomSheet:reveal-bottom-bar`). */
+    get revealBottomBar(): boolean;
+    /** Whether the sheet dims and blocks the content while open (`AdwBottomSheet:modal`). */
+    get modal(): boolean;
+    /** What the renderer has to show for the current state — {@link resolveBottomSheetChrome}. */
+    get chrome(): BottomSheetChrome;
     /** Set `can-close`. Returns whether it changed. */
     setCanClose(canClose: boolean): boolean;
+    /** Set `can-open`. Returns whether it changed. */
+    setCanOpen(canOpen: boolean): boolean;
+    /**
+     * Record whether a bottom bar is present. Returns whether it changed.
+     *
+     * A renderer calls this from wherever it adopts the bar widget — the C setter is where
+     * `update_swipe_tracker` is re-run (adw-bottom-sheet.c:1629), i.e. presence is an INPUT to
+     * the gates, not a rendering detail.
+     */
+    setHasBottomBar(hasBottomBar: boolean): boolean;
+    /**
+     * Set `modal`. Returns whether it changed. A sheet that is open changes its dimming at
+     * once, as `adw_bottom_sheet_set_modal` does (adw-bottom-sheet.c:1981-1982); `open` and
+     * the gates do not move, so nothing is notified here — the renderer repaints.
+     */
+    setModal(modal: boolean): boolean;
+    /** Set `reveal-bottom-bar`. Returns whether it changed. */
+    setRevealBottomBar(reveal: boolean): boolean;
     /**
      * The programmatic open/close — `adw_bottom_sheet_set_open`. Returns whether `open`
      * changed, i.e. whether a `notify::open` was emitted.
@@ -218,6 +375,12 @@ export declare class BottomSheetPresentation {
      * forwarded to the parent, or nothing at all.
      */
     requestClose(source: BottomSheetCloseSource): BottomSheetCloseOutcome;
+    /**
+     * Route an open affordance through {@link resolveBottomSheetOpen} and APPLY the outcome.
+     * `'ignored'` is the only other answer, and it is silent: libadwaita has no
+     * `open-attempt` counterpart to `close-attempt`, so a renderer emits nothing for it.
+     */
+    requestOpen(source: BottomSheetOpenSource): BottomSheetOpenOutcome;
     /**
      * The sheet has finished hiding — `open_animation_done_cb`'s teardown reduced to what a
      * renderer without a spring animation can observe. Fires `onClosed` and returns whether it

package/lib/types/gio-menu.d.ts

@@ -0,0 +1,46 @@
+import type { AdwMenuEntryInput, AdwMenuItemInput } from './menu.js';
+/**
+ * One menu item, built the way `g_menu_item_new` builds one.
+ *
+ * IT IS ITSELF A PORTABLE ENTRY — `implements AdwMenuItemInput` — so `append_item` pushes
+ * the instance and `normalizeMenuModel` reads its fields like any authored object. A
+ * separate internal shape would need a conversion the model does not ask for.
+ *
+ * Both halves are nullable, as they are in C: `g_menu_item_new(NULL, NULL)` is legal and
+ * produces an item carrying neither, which {@link normalizeMenuModel} drops rather than
+ * drawing an empty, unactionable row.
+ */
+export declare class GioMenuItem implements AdwMenuItemInput {
+    /** The user-visible string; ABSENT rather than `undefined` when the item has none. */
+    label?: string;
+    /** The DETAILED action name — `app.save-as`, `app.view::list` (ADR 0042 § divergence 2). */
+    action?: string;
+    constructor(label?: string | null, detailedAction?: string | null);
+    /** `g_menu_item_set_label`. `null` REMOVES the attribute, which is what C does. */
+    set_label(label: string | null): void;
+    /** `g_menu_item_set_detailed_action`, and `null` is `g_menu_item_set_action_and_target(…, NULL)`. */
+    set_detailed_action(detailedAction: string | null): void;
+}
+/**
+ * A menu under construction — `Gio.Menu`'s four append entry points over the portable model.
+ *
+ * `new GioMenu()` is empty, as `g_menu_new()` is. Every `append*` puts one entry on the end,
+ * and the instance IS the value a `menuModel` property takes.
+ */
+export declare class GioMenu extends Array<AdwMenuEntryInput> {
+    /** `g_menu_append` — the convenience C implements as `menu_item_new` + `append_item`. */
+    append(label: string | null, detailedAction?: string | null): void;
+    /** `g_menu_append_item`. */
+    append_item(item: GioMenuItem): void;
+    /**
+     * `g_menu_append_section` — the `section` LINK, whose items are drawn inline with a
+     * separator rather than behind a further click.
+     *
+     * The label is optional in C and stays optional here: a section with none is a plain
+     * group, and writing `label: null` onto the entry would be an attribute the model
+     * then has to ignore.
+     */
+    append_section(label: string | null, section: readonly AdwMenuEntryInput[]): void;
+    /** `g_menu_append_submenu` — the `submenu` LINK: a nested menu the user opens. */
+    append_submenu(label: string | null, submenu: readonly AdwMenuEntryInput[]): void;
+}

package/lib/types/gtk-adjustment.d.ts

@@ -0,0 +1,73 @@
+import type { AdwAdjustment, AdwAdjustmentInput } from './adjustment.js';
+/**
+ * What `new Gtk.Adjustment({ … })` takes: the GJS construct bag, which is exactly
+ * {@link AdwAdjustmentInput}.
+ *
+ * An ALIAS and not a second interface — the two would be one declaration copied, and the
+ * copy is the one that drifts when a seventh field arrives.
+ */
+export type GtkAdjustmentProps = AdwAdjustmentInput;
+/**
+ * A numeric range — `Gtk.Adjustment`'s six properties as a value an `adjustment` property
+ * takes.
+ *
+ * `new GtkAdjustment()` is `ADW_ADJUSTMENT_DEFAULTS` (0…100 step 1), which is the
+ * package's own default and NOT GTK's 0…0 step 0 — `adjustment.ts` says why in its header.
+ */
+export declare class GtkAdjustment implements AdwAdjustment {
+    /** The current value, within {@link adjustmentRange}. */
+    value: number;
+    /** The minimum value. */
+    lower: number;
+    /** The maximum value. */
+    upper: number;
+    /** How far one stepper press moves the value. */
+    stepIncrement: number;
+    /** How far one page press (Page Up/Down) moves the value. */
+    pageIncrement: number;
+    /** The size of the visible page; zero for a scalar value such as a spin row's. */
+    pageSize: number;
+    constructor(props?: GtkAdjustmentProps | null);
+    /**
+     * Re-establish the invariants around one authored change.
+     *
+     * The current six are the BASE, so a field nobody wrote keeps what it held instead of
+     * falling back to the package default — the same contract `SpinState.configure` has.
+     */
+    private _write;
+    /** `gtk_adjustment_configure` — all six at once, which is what C compresses into one. */
+    configure(value: number, lower: number, upper: number, step_increment: number, page_increment: number, page_size: number): void;
+    /** `gtk_adjustment_get_value`. */
+    get_value(): number;
+    /** `gtk_adjustment_set_value` — "clamped to lie between lower and upper". */
+    set_value(value: number): void;
+    /** `gtk_adjustment_get_lower`. */
+    get_lower(): number;
+    /** `gtk_adjustment_set_lower`. */
+    set_lower(lower: number): void;
+    /** `gtk_adjustment_get_upper`. */
+    get_upper(): number;
+    /** `gtk_adjustment_set_upper`. */
+    set_upper(upper: number): void;
+    /** `gtk_adjustment_get_step_increment`. */
+    get_step_increment(): number;
+    /** `gtk_adjustment_set_step_increment`. */
+    set_step_increment(step_increment: number): void;
+    /** `gtk_adjustment_get_page_increment`. */
+    get_page_increment(): number;
+    /** `gtk_adjustment_set_page_increment`. */
+    set_page_increment(page_increment: number): void;
+    /** `gtk_adjustment_get_page_size`. */
+    get_page_size(): number;
+    /** `gtk_adjustment_set_page_size`. */
+    set_page_size(page_size: number): void;
+    /**
+     * `gtk_adjustment_get_minimum_increment` — "the smaller of step increment and page
+     * increment", which is the GIR's own sentence.
+     *
+     * Total, with no zero case: `normalizeAdjustment` refuses a step of zero and carries
+     * the page increment with it, so both are positive here. C has to answer for the
+     * adjustment its own defaults produce, where either can be 0.
+     */
+    get_minimum_increment(): number;
+}

package/lib/types/gtk-adjustment.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/gtk-string-list.d.ts

@@ -0,0 +1,70 @@
+/**
+ * What `new Gtk.StringList({ … })` takes — the GJS spelling of the type's own
+ * construct-time properties.
+ *
+ * `strings` only. The other two `StringList` declares — `item-type` and `n-items` — are
+ * `GListModel`'s read-only pair, and a construct bag that accepted them would be offering
+ * a write the type does not have.
+ */
+export interface GtkStringListProps {
+    /** The strings the list starts with. */
+    strings?: readonly string[] | null;
+}
+/**
+ * A list of strings under construction — `Gtk.StringList`'s building half over a plain
+ * JS array.
+ *
+ * `new GtkStringList()` is empty, as `gtk_string_list_new(NULL)` is, and the instance IS
+ * the value a `model` property takes.
+ */
+export declare class GtkStringList extends Array<string> {
+    /** See the file header: `map`/`filter`/`slice` must not call this constructor. */
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(props?: GtkStringListProps | null);
+    /**
+     * `Gtk.StringList:strings`, as the door an attribute reaches. GTK's property is
+     * construct-only, and a NativeScript XML template has no constructor call to pass it
+     * through: `<gtk:StringList strings='["Blue","Teal"]'>` assigns the JSON text to this
+     * member instead, on a list that is still empty. So it REPLACES the contents, as
+     * constructing with `{ strings }` would have filled them.
+     */
+    get strings(): string[];
+    set strings(value: readonly string[] | string);
+    /** `gtk_string_list_append`. */
+    append(string: string): void;
+    /**
+     * `gtk_string_list_take` — `append` without the copy.
+     *
+     * The copy is what the two differ by in C ("this variant … is convenient for
+     * formatting strings"), and JS strings are immutable, so here the two are one
+     * function. It exists so code ported from GJS keeps working rather than to say
+     * something `append` does not.
+     */
+    take(string: string): void;
+    /** `gtk_string_list_remove` — the string at `position`, which must be in range. */
+    remove(position: number): void;
+    /**
+     * `gtk_string_list_splice` AND `Array.prototype.splice`, which is the point.
+     *
+     * The two say the same thing and pass the additions differently: C takes ONE array of
+     * them, JS takes them as rest arguments. A list whose elements are strings can tell
+     * the two apart with no ambiguity — an element is never an array — so both spellings
+     * work and a `list.splice(1, 2, ['a', 'b'])` ported straight from GJS inserts two
+     * strings instead of silently inserting one array as an element.
+     *
+     * `nRemovals` omitted is `Array.prototype.splice`'s "to the end", which is a different
+     * thing from passing `undefined` — so it is spelled as the count that reaches the end,
+     * which `splice` clamps the same way for a negative `position` as the one-argument form
+     * does.
+     *
+     * Flattened by hand, not `Array.prototype.flatMap` (ES2019): this source is also
+     * type-checked through `@gjsify/gtk-host`'s type-surface gate, whose `tsconfig`s
+     * pin `lib` to ES2017 for reasons of their own (`type-tests/{jsx,react}/tsconfig.json`)
+     * — a method this file alone would happily target ES2020 for is invisible there.
+     */
+    splice(position: number, nRemovals?: number, ...additions: readonly (string | readonly string[])[]): string[];
+    /** `gtk_string_list_get_string` — `null` past the end, as C returns `NULL`. */
+    get_string(position: number): string | null;
+    /** `g_list_model_get_n_items`, which a `GtkStringList` answers with its length. */
+    get_n_items(): number;
+}

package/lib/types/gtk-string-list.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/index.d.ts

@@ -22,14 +22,22 @@ export { ADW_DATA_GRID_ROW_VARIANTS, DATA_GRID_CELL_CLASS, DATA_GRID_ROW_CLASS,
 export type { AdwDataGridAlign, AdwDataGridCellValue, AdwDataGridColumn, AdwDataGridRow, AdwDataGridRowVariant, DataGridTrack, } from './data-grid.js';
 export { AdwToast, AdwToastQueue, DEFAULT_TOAST_TIMEOUT } from './toast.js';
 export type { AdwToastOptions, AdwToastQueueHandlers, AdwToastQueueOptions, ToastScheduler, ToastTimerHandle, } from './toast.js';
-export { AdwAlertResponses, BottomSheetPresentation, resolveBottomSheetClose } from './dialog.js';
-export type { AdwAlertResponse, AdwResponseAppearance, AdwResponseOptions, BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetCloseState, BottomSheetPresentationListener, BottomSheetPresentationOptions, BottomSheetTeardownCallback, OrderedConfirmResponses, } from './dialog.js';
+export { AdwAlertResponses, BottomSheetPresentation, resolveBottomSheetChrome, resolveBottomSheetClose, resolveBottomSheetOpen, resolveBottomSheetSwipeTracker, } from './dialog.js';
+export type { AdwAlertResponse, AdwResponseAppearance, AdwResponseOptions, BottomSheetChrome, BottomSheetChromeState, BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetCloseState, BottomSheetLayer, BottomSheetOpenOutcome, BottomSheetOpenSource, BottomSheetOpenState, BottomSheetPresentationListener, BottomSheetPresentationOptions, BottomSheetSwipeTrackerConfig, BottomSheetSwipeTrackerState, BottomSheetTeardownCallback, OrderedConfirmResponses, } from './dialog.js';
 export { ADW_COMBO_NO_SELECTION, clampListSelection, listItemsChanged, normalizeComboOptions, parseListModel, } from './list.js';
 export type { AdwComboOption, AdwComboOptionInput, AdwListItemsChanged, AdwListModel, AdwListModelInput, } from './list.js';
 export { ADW_ADJUSTMENT_DEFAULTS, adjustmentRange, clampAdjustmentValue, normalizeAdjustment, parseAdjustment, snapAdjustmentValue, SpinState, } from './adjustment.js';
 export type { AdwAdjustment, AdwAdjustmentInput, SpinStateChange, SpinStateListener, SpinStateRangeListener, } from './adjustment.js';
-export { ComboState, ExpanderState, ToggleGroupState } from './rows.js';
+export { GtkAdjustment } from './gtk-adjustment.js';
+export type { GtkAdjustmentProps } from './gtk-adjustment.js';
+export { GtkStringList } from './gtk-string-list.js';
+export type { GtkStringListProps } from './gtk-string-list.js';
+export { ComboState, ExpanderState, ToggleGroupState, keptToggles, toggleIndexOfName } from './rows.js';
 export type { ComboItemsListener, ComboStateChange, ComboStateListener, ExpanderStateListener, ToggleGroupStateChange, ToggleGroupStateListener, } from './rows.js';
+export { DEFAULT_BOX_SPACING, normalizeBoxOrientation, normalizeBoxSpacing } from './box.js';
+export type { BoxOrientation } from './box.js';
+export { DEFAULT_LABEL_ELLIPSIZE, DEFAULT_LABEL_LINES, DEFAULT_LABEL_MAX_WIDTH_CHARS, DEFAULT_LABEL_WIDTH_CHARS, DEFAULT_LABEL_WRAP_MODE, DEFAULT_LABEL_XALIGN, DEFAULT_LABEL_YALIGN, LABEL_ELLIPSIZE_MODES, LABEL_JUSTIFICATIONS, LABEL_WRAP_MODES, labelDisplayText, labelEffectiveLines, labelEllipsizeOverflowValue, labelMarkupIsUnparseable, labelWidthCharsExtent, labelYalignAlignItems, normalizeLabelEllipsize, normalizeLabelJustify, normalizeLabelLines, normalizeLabelMaxWidthChars, normalizeLabelWidthChars, normalizeLabelWrapMode, normalizeLabelXalign, normalizeLabelYalign, } from './label.js';
+export type { LabelAlignItems, LabelEllipsizeMode, LabelJustification, LabelWidthCharsExtent, LabelWrapMode, } from './label.js';
 export { glibClamp, gStrStrip, stringIsNotEmpty } from './glib.js';
 export { ViewStackState, normalizeIconName, resolvePageTitle } from './view-stack.js';
 export type { AdwViewStackPageInfo, AdwViewStackPageSpec, ViewStackStateChange, ViewStackStateListener, } from './view-stack.js';
@@ -50,6 +58,7 @@ export { ADW_SWIPE_BORDER, DEFAULT_MAX_SIDEBAR_WIDTH, DEFAULT_MIN_SIDEBAR_WIDTH,
 export type { AdwPackType, AdwTextDirection, NavigationActionInput, NavigationActionResult, NavigationPageRef, NavigationSplitViewChange, NavigationSplitViewHandlers, NavigationSplitViewLayout, NavigationSplitViewListener, NavigationSplitViewOptions, NavigationSplitViewProperty, NavigationStackPlan, OverlaySplitViewChange, OverlaySplitViewLayout, OverlaySplitViewListener, OverlaySplitViewOptions, OverlaySplitViewProperty, SidebarBounds, SidebarWidthInput, SidebarWidthSpec, SplitViewAnimation, SplitViewAnimationRequest, SplitViewAnimator, SplitViewMeasureInput, SplitViewPane, SplitViewPaneRect, SwipeReleasePlan, } from './split-view.js';
 export { DEFAULT_DROPDOWN_TOOLTIP, SPLIT_BUTTON_DISABLED_OPACITY, SplitButtonState, isSplitButtonDirection, menuButtonArrowIcon, menuButtonPopupDirection, resolveDropdownTooltip, splitButtonArrowIcon, splitButtonPopupDirection, splitButtonRootState, splitButtonStyleClasses, } from './split-button.js';
 export type { AdwArrowIcon, SplitButtonChange, SplitButtonContentMode, SplitButtonDirection, SplitButtonHalfState, SplitButtonListener, SplitButtonProperty, SplitButtonStyleClass, } from './split-button.js';
+export { GioMenu, GioMenuItem } from './gio-menu.js';
 export { ADW_MENU_SURFACE_NATIVESCRIPT, ADW_MENU_SURFACE_WEB, assertMenuRenderable, flattenMenu, menuItemAt, menuNodeAt, menuRefusals, normalizeMenuModel, parseDetailedAction, parseMenuModel, resolveMenuItemState, } from './menu.js';
 export type { AdwDetailedAction, AdwMenuAction, AdwMenuActions, AdwMenuDisplayHint, AdwMenuEntryInput, AdwMenuFlatRow, AdwMenuHiddenWhen, AdwMenuInput, AdwMenuItem, AdwMenuItemInput, AdwMenuItemRole, AdwMenuItemState, AdwMenuModel, AdwMenuNode, AdwMenuPath, AdwMenuRefusal, AdwMenuSection, AdwMenuSectionInput, AdwMenuSubmenu, AdwMenuSubmenuInput, AdwMenuSurface, AdwMenuTextDirection, } from './menu.js';
 export { DEFAULT_INDICATOR_DESCRIPTION_STRINGS, INLINE_VIEW_SWITCHER_DISPLAY_MODES, VIEW_SWITCHER_BADGE_LIMIT, VIEW_SWITCHER_DRAG_SWITCH_DELAY, VIEW_SWITCHER_FALLBACK_ICON, VIEW_SWITCHER_NO_SELECTION, VIEW_SWITCHER_POLICIES, ViewSwitcherBarState, ViewSwitcherDragSwitch, ViewSwitcherState, buildInlineToggles, buildViewSwitcherButtons, createViewSwitcherPage, inlineToggleTooltip, isInlineViewSwitcherDisplayMode, isViewSwitcherButtonVisible, isViewSwitcherPolicy, pageIndexForToggle, shouldRevealViewSwitcherBar, stripMnemonic, toggleIndexForPage, viewSwitcherBadgeLabel, viewSwitcherButtonOrientation, viewSwitcherIconName, viewSwitcherIndicatorDescription, viewSwitcherLabel, viewSwitcherPageFromStackPage, viewSwitcherPagesFromStack, } from './view-switcher.js';
@@ -74,3 +83,5 @@ export { POPOVER_ITEM_RADIUS, POPOVER_MENU_PADDING, POPOVER_PADDING, POPOVER_RAD
 export type { PopoverKeyAction, PopoverKeyContext, PopoverKeyResolution, PopoverStateChange, PopoverStateListener, } from './popover.js';
 export { ADW_WRAP_BOX_DEFAULT_ALIGN, ADW_WRAP_BOX_DEFAULT_JUSTIFY, ADW_WRAP_BOX_DEFAULT_JUSTIFY_LAST_LINE, ADW_WRAP_BOX_DEFAULT_LENGTH_UNIT, ADW_WRAP_BOX_DEFAULT_PACK_DIRECTION, ADW_WRAP_BOX_DEFAULT_SPACING, ADW_WRAP_BOX_DEFAULT_WRAP_POLICY, ADW_WRAP_BOX_JUSTIFY_MODES, ADW_WRAP_BOX_NATURAL_LINE_LENGTH_UNSET, ADW_WRAP_BOX_PACK_DIRECTIONS, ADW_WRAP_POLICIES, normalizeNaturalLineLength, normalizeWrapBoxAlign, normalizeWrapBoxJustify, normalizeWrapBoxLengthUnit, normalizeWrapBoxPackDirection, normalizeWrapBoxSpacing, normalizeWrapPolicy, resolveWrapBoxChildOrder, resolveWrapBoxLine, wrapBoxChildFlex, wrapBoxFlexStyle, wrapBoxLengthToPx, wrapPolicyFlexShrink, } from './wrap-box.js';
 export type { AdwWrapBoxJustify, AdwWrapBoxOrientation, AdwWrapBoxPackDirection, AdwWrapPolicy, WrapBoxChildFlex, WrapBoxChildOrderOp, WrapBoxFlexInput, WrapBoxFlexStyle, WrapBoxLineLayout, } from './wrap-box.js';
+export { ADW_SOURCE_6502_DIRECTIVES, ADW_SOURCE_6502_LINE_COMMENT, ADW_SOURCE_6502_OPCODES, ADW_SOURCE_6502_REGISTERS, ADW_SOURCE_6502_TOKEN_ROLES, ADW_SOURCE_HEX_STRIDE, ADW_SOURCE_PALETTE_DARK, ADW_SOURCE_PALETTE_LIGHT, ADW_SOURCE_SYNTAX_ROLES, classifyAsm6502Word, formatHexAddress, formatLineNumber, stripSourceWhitespace, tokenizeAsm6502, } from './source.js';
+export type { AdwSourcePalette, AdwSourceSyntaxRole, AdwSourceTokenClass, AdwSourceTokenStream } from './source.js';

package/lib/types/label.d.ts

@@ -0,0 +1,135 @@
+/** `Gtk.Label:xalign`'s default — `0.5` in the pspec: a label centres its text. */
+export declare const DEFAULT_LABEL_XALIGN = 0.5;
+/** `Gtk.Justification`'s four nicks, in enum order. */
+export declare const LABEL_JUSTIFICATIONS: readonly ["left", "right", "center", "fill"];
+export type LabelJustification = (typeof LABEL_JUSTIFICATIONS)[number];
+/**
+ * The string a label shows for a given `label` and the two flags that transform it.
+ *
+ * ORDER 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 that could not be reduced, so the raw string is shown. */
+export declare function labelMarkupIsUnparseable(label: string, useMarkup: boolean): boolean;
+/**
+ * `Gtk.Label:xalign` as the label holds it. `gtk_label_set_xalign` CLAMPs to 0…1 itself,
+ * so an out-of-range value lands on the nearer end; only an unparseable one is the default.
+ */
+export declare function normalizeLabelXalign(value: unknown): number;
+/** `Gtk.Label:justify` from its nick. An unknown nick leaves the default, `left`. */
+export declare function normalizeLabelJustify(value: unknown): LabelJustification;
+/** `Gtk.Label:yalign`'s default — `0.5`, the same pspec shape as `xalign`. */
+export declare const DEFAULT_LABEL_YALIGN = 0.5;
+/**
+ * `Gtk.Label:yalign` as the label holds it. `gtk_label_set_yalign` CLAMPs to 0…1 itself,
+ * the same shape `normalizeLabelXalign` already carries for `xalign`.
+ */
+export declare function normalizeLabelYalign(value: unknown): number;
+/** The one CSS `align-items` keyword a `yalign` zone maps to. */
+export type LabelAlignItems = 'flex-start' | 'center' | 'flex-end';
+/**
+ * `yalign`'s three-zone CSS mapping — the DECLARED divergence past `yalign`'s three exact
+ * values (0, 0.5, 1): CSS `align-items` has three keywords and no ratio the way `xalign`'s
+ * `flex-grow` gives the main axis one (`_labels.scss`'s header has the full reasoning for
+ * why a second spacer pair is not the fix). This is the NEAREST of the three — the
+ * boundary between "nearest 0" and "nearest 0.5" is their midpoint, `0.25`, and
+ * symmetrically `0.75` between "nearest 0.5" and "nearest 1"; a value sitting exactly on a
+ * boundary is equidistant and reads as the CENTRE zone (`<`/`>`, not `<=`/`>=`), the same
+ * "high bound first" tie a strict inequality gives {@link glibClamp} at its own edges.
+ */
+export declare function labelYalignAlignItems(yalign: number): LabelAlignItems;
+/** `Pango.EllipsizeMode`'s four nicks, in enum order. */
+export declare const LABEL_ELLIPSIZE_MODES: readonly ["none", "start", "middle", "end"];
+export type LabelEllipsizeMode = (typeof LABEL_ELLIPSIZE_MODES)[number];
+/** `Gtk.Label:ellipsize`'s default — `none`, no ellipsization. */
+export declare const DEFAULT_LABEL_ELLIPSIZE: LabelEllipsizeMode;
+/** `Gtk.Label:ellipsize` from its nick. An unknown nick leaves the default, `none`. */
+export declare function normalizeLabelEllipsize(value: unknown): LabelEllipsizeMode;
+/**
+ * `Gtk.Label:ellipsize` as the ONE truncating value CSS `text-overflow` and
+ * NativeScript's `textOverflow` can both hold — each accepts only `clip` or `ellipsis`,
+ * neither has a start- or middle-truncating mode of its own.
+ *
+ * `start` and `middle` are held on the PROPERTY faithfully: `normalizeLabelEllipsize`
+ * never lies about what was asked for, and a consumer reading `label.ellipsize` back gets
+ * exactly that nick. What a renderer can DRAW is a different question, answered here once
+ * for both renderers so neither invents its own fallback: every non-`none` mode draws an
+ * END ellipsis, the nearer of the two values a platform actually has — never a silent
+ * `clip`, which would drop the same characters with no indication at all that anything is
+ * missing. A DECLARED divergence, not a guessed one: `LABEL_ELLIPSIZE_OVERFLOW_VECTORS`
+ * pins this fallback, the same way `LABEL_DISPLAY_TEXT_VECTORS` pins use-markup's.
+ */
+export declare function labelEllipsizeOverflowValue(ellipsize: LabelEllipsizeMode): 'clip' | 'ellipsis';
+/** `Pango.WrapMode`'s three nicks, in enum order. */
+export declare const LABEL_WRAP_MODES: readonly ["word", "char", "word-char"];
+export type LabelWrapMode = (typeof LABEL_WRAP_MODES)[number];
+/** `Gtk.Label:wrap-mode`'s default — `word`, wrap on word boundaries. */
+export declare const DEFAULT_LABEL_WRAP_MODE: LabelWrapMode;
+/** `Gtk.Label:wrap-mode` from its nick. An unknown nick leaves the default, `word`. */
+export declare function normalizeLabelWrapMode(value: unknown): LabelWrapMode;
+/** `Gtk.Label:width-chars`'s default — `-1`, the width is calculated automatically. */
+export declare const DEFAULT_LABEL_WIDTH_CHARS = -1;
+/** `Gtk.Label:width-chars` as the label holds it. See {@link normalizeLabelCharCount}. */
+export declare function normalizeLabelWidthChars(value: unknown): number;
+/** `Gtk.Label:max-width-chars`'s default — `-1`, the width is calculated automatically. */
+export declare const DEFAULT_LABEL_MAX_WIDTH_CHARS = -1;
+/** `Gtk.Label:max-width-chars` as the label holds it. See {@link normalizeLabelCharCount}. */
+export declare function normalizeLabelMaxWidthChars(value: unknown): number;
+/** `Gtk.Label:lines`'s default — `-1`, no line limit. */
+export declare const DEFAULT_LABEL_LINES = -1;
+/** `Gtk.Label:lines` as the label holds it. See {@link normalizeLabelCharCount}. */
+export declare function normalizeLabelLines(value: unknown): number;
+/**
+ * `Gtk.Label:lines` — the line count Pango will actually show before it ellipsizes, or
+ * `null` when nothing caps it at all.
+ *
+ * THE PSPEC'S OWN WORDS ARE IMPRECISE, MEASURED AGAINST WHAT GTK DOES. "Has no effect if
+ * the label is not wrapping or ellipsized" reads as `wrap || ellipsize !== 'none'` — this
+ * function's first, WRONG implementation — but `gtk_label_ensure_layout` (gtklabel.c) only
+ * ever calls `pango_layout_set_height(layout, -self->lines)`, and `wrap` plays NO PART in
+ * whether Pango HONOURS that call: measured on gjs 1.88.1 / gtk 4.22.5, a real
+ * `Gtk.Label` with `wrap=TRUE, ellipsize=NONE, lines=2`, allocated 100px wide, laid out
+ * **15 lines** — the `lines` hint sits there unused, because Pango only consults a
+ * layout's height/line-count when ELLIPSIZATION is active; wrapping alone never asks
+ * Pango to stop. The same label with `wrap=FALSE, ellipsize=END, lines=2` (the case the
+ * old implementation returned `null`, "no effect", for) laid out exactly **2 lines**,
+ * ellipsized — `wrap` is `false` there and it changed nothing: `ellipsize || wrap` in the
+ * C is the gate on whether the layout gets a WIDTH at all (a `Gtk.Label:ellipsize`
+ * request supplies its own width, exactly like `wrap` does), not on whether `lines` has
+ * an effect. So `wrap` is not a parameter here — passing it would invite exactly the
+ * misreading the pspec's prose does.
+ *
+ * WHAT AN UNSET `lines` (`≤ 0`) MEANS ONCE ELLIPSIZE IS ACTIVE IS NOT "UNLIMITED" — it is
+ * Pango's OWN default: `gtk_label_set_lines` only calls `pango_layout_set_height` when
+ * `lines > 0`, so an unset `lines` leaves Pango's height at ITS default, which
+ * `PangoLayout` documents as "the first line will be shown" — measured: `lines` absent
+ * (or `0`) with `ellipsize=END` laid out to exactly **1 line**, same as `lines=1`
+ * explicitly. `lines < 0` (GTK's own "unlimited" spelling once `lines` IS being read,
+ * i.e. while ellipsize is active) was never reachable through this function in the first
+ * place, since {@link normalizeLabelLines} floors at `-1` and this reads it before any
+ * positive check — folded into the `lines > 0 ? lines : 1` branch below.
+ */
+export declare function labelEffectiveLines(lines: number, ellipsize: LabelEllipsizeMode): number | null;
+/** One `width-chars` + `max-width-chars` pair and the `ch`-unit extent a renderer draws. */
+export interface LabelWidthCharsExtent {
+    /** `width-chars`, in `ch` — the MINIMUM width — or `null` while it is unset (`-1`). */
+    minCh: number | null;
+    /**
+     * `MAX(width-chars, max-width-chars)`, in `ch` — the NATURAL/maximum width — or `null`
+     * while `max-width-chars` is unset. `width-chars` alone sets no maximum: GTK reads it
+     * only as a floor under `max-width-chars`, never as a ceiling by itself.
+     */
+    maxCh: number | null;
+}
+/**
+ * `get_default_widths` (gtklabel.c): the label's MINIMUM width is `width-chars` alone; its
+ * NATURAL width is `MAX(width-chars, max-width-chars)`, and that MAX is read only while
+ * `max-width-chars` is set — `width-chars` without a maximum has nothing to be a floor
+ * under. Either property at its default (`-1`) drops out of the pair it belongs to, the
+ * same "negative means auto" rule both share.
+ */
+export declare function labelWidthCharsExtent(widthChars: number, maxWidthChars: number): LabelWidthCharsExtent;

package/lib/types/label.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/markup.d.ts

@@ -0,0 +1,14 @@
+import type { SharedTreeNode } from './conformance/shared-trees.js';
+/**
+ * The tree as `<adw-*>`/`<gtk-*>` markup: what `buildSharedTree` would build, spelled as the
+ * HTML a page could hold instead. Parsed into a document, it yields the same elements with
+ * the same attributes, classes and `slot=` as `mountSharedTree(node)` does.
+ */
+export declare function sharedTreeHtml(node: SharedTreeNode): string;
+/**
+ * The tree as a NativeScript XML template: what the port's `build` would build, spelled as
+ * markup NativeScript's `Builder` loads. The root declares NativeScript's default namespace
+ * and one `xmlns` barrel per library the tree uses — no more, since each is a module the app
+ * then has to provide.
+ */
+export declare function sharedTreeNativeScriptXml(node: SharedTreeNode): string;

package/lib/types/markup.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/rows.d.ts

@@ -222,3 +222,23 @@ export declare class ToggleGroupState {
     /** Number of segments. */
     get count(): number;
 }
+/**
+ * The toggles a group keeps, in add order.
+ *
+ * A NAME IS UNIQUE, AND THE SECOND CLAIM IS REFUSED WHOLE. `add_toggle` looks the name up
+ * before adding and, when another toggle already carries it, prints a `g_critical` and
+ * drops the toggle — it is never added, so it draws no button and takes no index
+ * (adw-toggle-group.c:849). An unnamed toggle is always kept.
+ */
+export declare function keptToggles<T extends {
+    readonly name?: string | null;
+}>(toggles: readonly T[]): T[];
+/**
+ * The toggle `adw_toggle_group_set_active_name` selects: its index among the names of the
+ * KEPT toggles ({@link keptToggles}), or `-1` when none carries `name`.
+ *
+ * `-1` is not a selection. The C answers a name nothing carries with a `g_critical` and
+ * returns (:2001) — the active toggle stays where it was — so a renderer leaves its
+ * selection alone on `-1` rather than clearing it.
+ */
+export declare function toggleIndexOfName(names: readonly (string | null | undefined)[], name: string): number;