@gjsify/adwaita-web 0.31.0 → 0.33.0

package/lib/types/elements/adw-tab-view.d.ts

@@ -1,19 +1,41 @@
-/** A single page. Children of <adw-tab-view>; consumed at connect time. */
+import type { AdwTabPageSpec, AdwTabPageState } from '@gjsify/adwaita-core';
+/** A page descriptor as `pages` exposes it. */
+export type AdwTabViewPage = AdwTabPageState<HTMLElement>;
+/** The page spec the imperative insertion methods take. */
+export type AdwTabViewPageSpec = AdwTabPageSpec<HTMLElement>;
+/**
+ * A single page. Declared as a child of <adw-tab-view>; the element itself
+ * becomes the page panel, so its attributes keep driving the tab after connect —
+ * the old implementation moved the children out and discarded the element, which
+ * is why its `observedAttributes` declaration had nothing to act on.
+ */
 export declare class AdwTabPage extends HTMLElement {
     static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
 }
 export declare class AdwTabView extends HTMLElement {
-    private _barEl;
-    private _pagesEl;
-    private _tabs;
-    private _pages;
-    private _selected;
+    private readonly _state;
+    private readonly _barEl;
+    private readonly _tabBoxEl;
+    private readonly _pagesEl;
+    /** Tab chips keyed by page id — the bar is edited in place, never rebuilt. */
+    private readonly _tabs;
+    /** Page panels keyed by page id; kept so a DETACHED page's node is still reachable. */
+    private readonly _panels;
+    private readonly _hovered;
     private _initialized;
+    private _generatedIds;
+    /** Guards the `selected` attribute reflection against re-entering the model. */
+    private _reflecting;
     static get observedAttributes(): string[];
-    /** Zero-based index of the visible page. */
+    constructor();
+    /** Zero-based index of the visible page, `-1` when the view is empty. */
     get selected(): number;
     set selected(value: number);
-    /** Whether the tab bar hides itself when only one page remains. */
+    /**
+     * Whether the tab bar hides itself when it has nothing to show —
+     * `tabsRevealed`, which keeps the bar up for a single PINNED tab.
+     */
     get autohide(): boolean;
     set autohide(value: boolean);
     /** Whether tabs stretch to fill the bar evenly (Adw.TabBar `expand-tabs`). */
@@ -23,8 +45,103 @@ export declare class AdwTabView extends HTMLElement {
     get noClose(): boolean;
     set noClose(value: boolean);
     connectedCallback(): void;
-    attributeChangedCallback(name: string): void;
-    private _readSelectedAttr;
-    private _selectIndex;
-    private _render;
+    attributeChangedCallback(name: string, _old: string | null, _value: string | null): void;
+    /**
+     * Push a live `<adw-tab-page>` attribute change into the model. Called by
+     * {@link AdwTabPage.attributeChangedCallback}; not part of the public API.
+     */
+    syncDeclaredPage(pageEl: AdwTabPage, name: string, value: string | null): void;
+    /** All pages in order. */
+    get pages(): readonly AdwTabViewPage[];
+    /** Number of pages. */
+    get nPages(): number;
+    /** Length of the pinned prefix. */
+    get nPinnedPages(): number;
+    /** Id of the selected page, `null` when the view is empty. */
+    get selectedId(): string | null;
+    /** Index of the selected page, `-1` when the view is empty. */
+    get selectedIndex(): number;
+    /** The selected page's panel element, or `null`. */
+    get selectedContent(): HTMLElement | null;
+    isClosing(id: string): boolean;
+    setSelectedPage(id: string | null): boolean;
+    selectNthPage(n: number): boolean;
+    selectPreviousPage(): boolean;
+    selectNextPage(): boolean;
+    selectFirstPage(): boolean;
+    selectLastPage(): boolean;
+    /** Ctrl+Tab — the next page, wrapping to the first. */
+    cycleNextPage(): boolean;
+    /** Ctrl+Shift+Tab — the previous page, wrapping to the last. */
+    cyclePreviousPage(): boolean;
+    /** Add a page opened FROM `parentId`, deriving its position (Adw.TabView.add_page). */
+    addPage(spec: AdwTabViewPageSpec, parentId?: string | null): number;
+    insertPage(spec: AdwTabViewPageSpec, position: number): number;
+    prependPage(spec: AdwTabViewPageSpec): number;
+    appendPage(spec: AdwTabViewPageSpec): number;
+    insertPinnedPage(spec: AdwTabViewPageSpec, position: number): number;
+    prependPinnedPage(spec: AdwTabViewPageSpec): number;
+    appendPinnedPage(spec: AdwTabViewPageSpec): number;
+    /** Pin or unpin a page, re-ordering it in the same step. Returns its new position. */
+    setPagePinned(id: string, pinned: boolean): number;
+    /**
+     * Request a close. Dispatches a CANCELABLE `close-page`; calling
+     * `preventDefault()` on it holds the page open until {@link closePageFinish}.
+     */
+    closePage(id: string): boolean;
+    closePageFinish(id: string, confirm: boolean): boolean;
+    closeOtherPages(id: string): void;
+    closePagesBefore(id: string): void;
+    closePagesAfter(id: string): void;
+    /** Remove a page unconditionally, running the successor rule first. */
+    detachPage(id: string): AdwTabViewPage | null;
+    reorderPage(id: string, position: number): boolean;
+    reorderBackward(id: string): boolean;
+    reorderForward(id: string): boolean;
+    reorderFirst(id: string): boolean;
+    reorderLast(id: string): boolean;
+    setPageTitle(id: string, title: string | null): boolean;
+    setPageTooltip(id: string, tooltip: string | null): boolean;
+    setPageIcon(id: string, icon: string | null): boolean;
+    setPageLoading(id: string, loading: boolean): boolean;
+    setPageNeedsAttention(id: string, needsAttention: boolean): boolean;
+    /** Every precondition the model refused, as C would have warned about it. */
+    get diagnostics(): readonly string[];
+    private _adoptDeclaredPage;
+    /** Give a spec its panel, so `append({ id })` with no content is legal. */
+    private _withPanel;
+    private _nextId;
+    private _onPagesChange;
+    private _insertTab;
+    /** Remove-then-insert, the same shape the model's own reorder has. */
+    private _moveTab;
+    private _refreshTab;
+    /**
+     * `tabCloseVisible` (adw-tab.c:124 + the pinned gate at :645-650). `dragging`
+     * is constantly false — tab drag-and-drop is compositor work and is not
+     * modelled — and `fullyVisible` is measured against the bar's scroll window,
+     * which is exactly what the C term means for a horizontally scrolled bar.
+     */
+    private _refreshCloseVisibility;
+    private _onSelectionChange;
+    private _applyActiveState;
+    private _applyBarVisibility;
+    private _reflectSelected;
+    private _applySelectedAttribute;
+    /**
+     * The `Adw.TabView` shortcut table (`init_shortcuts`, adw-tab-view.c:2192+),
+     * plus the ArrowLeft/ArrowRight movement `role=tablist` promises.
+     *
+     * Ctrl+Tab WRAPS and Ctrl+Page-Up/Down does not — the same `last` flag that
+     * separates them in `select_page_cb` (:2017-2041). Alt+0 is page index 9,
+     * because pages count from 0 (:2149-2150).
+     */
+    private _onKeyDown;
+    /**
+     * The `close-page` seam. A CANCELABLE DOM event is the idiomatic spelling of
+     * the C signal's return value: letting it through takes libadwaita's default
+     * (`!pinned`, adw-tab-view.c:1990-1991), and `preventDefault()` defers the
+     * close until the app calls {@link closePageFinish}.
+     */
+    private _requestClose;
 }

package/lib/types/elements/adw-toolbar-view.d.ts

@@ -3,6 +3,8 @@ export declare class AdwToolbarView extends HTMLElement {
     private _contentEl;
     private _bottomEl;
     private _initialized;
+    private _resize;
+    static get observedAttributes(): string[];
     /** The top-bar container — append header bars here imperatively. */
     get topBar(): HTMLDivElement;
     /** The scrollable content container. */
@@ -10,4 +12,7 @@ export declare class AdwToolbarView extends HTMLElement {
     /** The bottom-bar container. */
     get bottomBar(): HTMLDivElement;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    private _syncClasses;
 }

package/lib/types/elements/adw-view-stack.d.ts

@@ -1,37 +1,57 @@
+import type { AdwViewStackPageInfo as CorePageInfo } from '@gjsify/adwaita-core';
 /** A page descriptor exposed via `pages` (consumed by a bound switcher bar). */
-export interface AdwViewStackPageInfo {
-    /** Stable id used by visibleChildName + switcher binding. */
-    name: string;
-    /** Human-facing title shown by a bound switcher. */
-    title: string;
-    /** Symbolic icon name (no `-symbolic` suffix), or '' for none. */
-    icon: string;
-    /** The page's content container (the visibility-toggled node). */
-    element: HTMLElement;
-}
+export type AdwViewStackPageInfo = CorePageInfo<HTMLElement>;
 export declare class AdwViewStack extends HTMLElement {
-    private _pages;
-    private _visibleIndex;
+    private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];
+    constructor();
     /** All pages in declaration/add order. A bound switcher reads this. */
     get pages(): readonly AdwViewStackPageInfo[];
-    /** Zero-based index of the visible page. Out-of-range/same values no-op. */
+    /** Zero-based index of the visible page, `-1` when nothing is selected. */
     get visibleChildIndex(): number;
     set visibleChildIndex(value: number);
-    /** Name of the visible page, or '' when the stack is empty. */
+    /** Name of the visible page, or '' when nothing is selected. */
     get visibleChildName(): string;
-    set visibleChildName(name: string);
-    /** The visible page's content element, or null when empty. */
+    set visibleChildName(name: string | null | undefined);
+    /** The visible page's content element, or null when nothing is selected. */
     get visibleChild(): HTMLElement | null;
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     /**
-     * Append a page. The FIRST page added becomes visible automatically; later
-     * pages are added hidden. Mirrors Adw.ViewStack.add()/the NS twin's add().
+     * Append a page. It becomes visible when nothing is selected yet, matching
+     * `Adw.ViewStack.add()` — and, unlike before, that auto-pick NOTIFIES.
      */
     add(content: HTMLElement, name: string, title?: string, icon?: string): AdwViewStackPageInfo;
     /** Convenience alias mirroring Adw.ViewStack.add_titled() (no icon). */
     addTitled(content: HTMLElement, name: string, title: string): AdwViewStackPageInfo;
-    private _apply;
+    /**
+     * Remove the first page named `name` and detach its content. Returns whether
+     * anything was removed. When the removed page was the visible one the stack
+     * ends up showing NOTHING and emits no event — `stack_remove` clears
+     * `visible_child` without re-picking (adw-view-stack.c:1202-1203).
+     */
+    removePage(name: string): boolean;
+    /**
+     * Show or hide a page (`AdwViewStackPage:visible`). Returns whether the
+     * SELECTION moved: hiding the visible page falls back to the next visible
+     * one, and making a page visible while nothing is selected selects it
+     * (`update_child_visible`, adw-view-stack.c:1061-1082).
+     */
+    setPageVisible(name: string, visible: boolean): boolean;
+    /**
+     * The pages model's `items-changed`, which the DOM stack had no counterpart
+     * for at all.
+     *
+     * `AdwViewSwitcherBar` re-runs `update_bar_revealed` on it
+     * (adw-view-switcher-bar.c:340) and `AdwViewSwitcher` rebinds its buttons
+     * (adw-view-switcher.c:258-263). Both ports listened only on
+     * `notify::visible-child`, so adding a page or hiding a non-selected one
+     * left `revealed` — and the button row — stale, with a manual `refresh()`
+     * as the documented workaround.
+     */
+    private _emitItemsChanged;
+    private _onStateChange;
+    private _applyVisibility;
+    private _reflectName;
 }

package/lib/types/elements/adw-view-switcher-bar.d.ts

@@ -1,27 +1,45 @@
 import type { AdwViewStack } from './adw-view-stack.js';
 export declare class AdwViewSwitcherBar extends HTMLElement {
+    private readonly _barState;
     private _barEl;
-    private _buttons;
+    private _nodes;
     private _stack;
-    private _revealed;
     private _initialized;
-    private _onStackNotify;
+    private readonly _onStackNotify;
     static get observedAttributes(): string[];
+    constructor();
     /** The bound stack element, or null when unbound. */
     get stack(): AdwViewStack | null;
     set stack(value: AdwViewStack | string | null);
-    /** Whether the bar is revealed (shown). Hidden when false. */
+    /** Whether the layout asked for the bar — `Adw.ViewSwitcherBar:reveal`. */
+    get reveal(): boolean;
+    set reveal(value: boolean);
+    /**
+     * Whether the bar is actually shown. READ-ONLY: a one-page stack keeps it
+     * collapsed however loudly the layout asks (adw-view-switcher-bar.c:125).
+     * Write {@link reveal} to make the request.
+     */
     get revealed(): boolean;
-    set revealed(value: boolean);
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     /** Bind to a stack element (or null). Unbinds the previous one and rebuilds. */
     setStack(stack: AdwViewStack | null): void;
-    /** Rebuild the buttons — call after adding pages to the bound stack. */
+    /**
+     * Rebuild the buttons by hand.
+     *
+     * Kept as public API — a consumer that mutates a page in place still has a
+     * way to say so — but no longer the ONLY way: the stack emits
+     * `items-changed` now and this bar binds it, which is the mechanism
+     * libadwaita uses (adw-view-switcher-bar.c:340,
+     * adw-view-switcher.c:258-263).
+     */
     refresh(): void;
+    private _readReveal;
+    private _bindStack;
+    private _unbindStack;
     private _resolveStack;
     private _rebuild;
-    private _syncActive;
+    private _buildButton;
     private _applyRevealed;
 }

package/lib/types/elements/adw-view-switcher.d.ts

@@ -1,29 +1,92 @@
-type Policy = 'wide' | 'narrow';
-/** A single page. Children of <adw-view-switcher>; consumed at connect time. */
+import type { ViewSwitcherScheduler } from '@gjsify/adwaita-core';
+import type { AdwViewSwitcherPage as AdwViewSwitcherPageInfo, AdwViewSwitcherPolicy } from '@gjsify/adwaita-core';
+/**
+ * A single page. Children of `<adw-view-switcher>`; consumed at connect time.
+ *
+ * Deliberately carries NO `observedAttributes`. It used to declare six of them
+ * and no `attributeChangedCallback`, which is a dead declaration — the browser
+ * computes the list and has nowhere to deliver to — so changing `badge-number`,
+ * `title`, `icon-name` or `needs-attention` after connect did nothing at all,
+ * where C rebinds on every page `notify` (adw-view-switcher.c:184-193, :223).
+ *
+ * A callback could not fix it either: the switcher consumes these elements at
+ * connect and `replaceChildren`s them away, so a detached page has no `closest`
+ * to reach its owner through. The switcher watches them with a `MutationObserver`
+ * instead, which keeps working after the detach and needs nothing from this class.
+ */
 export declare class AdwViewSwitcherPage extends HTMLElement {
-    static get observedAttributes(): string[];
 }
 export declare class AdwViewSwitcher extends HTMLElement {
+    /**
+     * The dwell timer, injectable.
+     *
+     * It used to be `new ViewSwitcherState({ scheduler: domViewSwitcherScheduler })`
+     * inline, which left NOWHERE to hand a clock in — so
+     * `VIEW_SWITCHER_DRAG_VECTORS` was driven by the core suite alone, and the
+     * conformance header claimed all three suites drove it. `scheduler` is a
+     * property so a test can replace it before the element connects; the DOM one
+     * is the default, exactly as before.
+     */
+    scheduler: ViewSwitcherScheduler;
+    private _stateInstance;
+    /** Built on first access, so a `scheduler` set before connect is the one used. */
+    private get _state();
     private _barEl;
     private _contentEl;
-    private _pages;
-    private _active;
+    private _nodes;
+    /** The page ELEMENTS, kept because the switcher detaches them from the tree. */
+    private _declared;
+    private _pageObserver;
     private _policy;
     private _initialized;
     static get observedAttributes(): string[];
+    constructor();
     /** The policy controlling the button layout ('wide' | 'narrow'). */
-    get policy(): Policy;
-    set policy(value: Policy);
-    /** Zero-based index of the active page. */
+    get policy(): AdwViewSwitcherPolicy;
+    set policy(value: AdwViewSwitcherPolicy);
+    /** Zero-based index of the selected page, `-1` when nothing is selected. */
     get active(): number;
     set active(value: number);
-    /** The name of the currently visible page, or null when there are none. */
-    get visibleChildName(): string | null;
+    /** Name of the selected page, `''` when nothing is selected. */
+    get visibleChildName(): string;
+    set visibleChildName(name: string | null | undefined);
+    /** The resolved page records a bound layout can read. */
+    get pages(): readonly AdwViewSwitcherPageInfo[];
+    /**
+     * Show or hide a page (`AdwViewStackPage:visible`). Returns whether the
+     * SELECTION moved — hiding the selected page falls back to the first still
+     * visible one (adw-view-stack.c:1061-1082).
+     */
+    setPageVisible(name: string, visible: boolean): boolean;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Re-read every declared page and push it into the state.
+     *
+     * Called by `AdwViewSwitcherPage.attributeChangedCallback`, which is what
+     * makes a runtime `badge-number` change reach the button. `setPages` keeps
+     * the selection where it can, so this is a repaint and not a reset.
+     */
+    refreshPages(): void;
+    /**
+     * Watch the declared pages for attribute changes.
+     *
+     * A `MutationObserver` rather than an `attributeChangedCallback` on the page:
+     * the switcher consumes those elements at connect and `replaceChildren`s them
+     * out of the tree, so a detached page cannot find its owner — but an observer
+     * bound to it keeps firing. This is the DOM's `notify::` on
+     * `AdwViewStackPage`, which the C's `update_button` handler binds per page
+     * (adw-view-switcher.c:184-193).
+     *
+     * It delivers on a MICROTASK where GTK's notify is synchronous. That is the
+     * DOM's contract for watching a node, it is invisible to a user, and nothing
+     * in this element reads the button back inside the setter.
+     */
+    private _watchPages;
     attributeChangedCallback(name: string): void;
+    private _buildPage;
     private _readPolicyAttr;
-    private _readActiveAttr;
-    private _selectIndex;
+    private _onStateChange;
     private _render;
+    private _reflectActive;
 }
-export {};

package/lib/types/elements/adw-window-title.d.ts

@@ -1,9 +1,11 @@
 export declare class AdwWindowTitle extends HTMLElement {
     private _titleEl;
     private _subtitleEl;
+    /** The headless title/subtitle pair + change detection (ADR 0004). */
+    private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];
     connectedCallback(): void;
-    attributeChangedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     private _render;
 }

package/lib/types/elements/adw-wrap-box.d.ts

@@ -1,13 +1,68 @@
+import { type AdwLengthUnit } from '@gjsify/adwaita-core';
 export declare class AdwWrapBox extends HTMLElement {
     private _initialized;
-    static get observedAttributes(): string[];
-    /** Spacing between children on the same line, in px (CSS column-gap). */
+    static get observedAttributes(): ("align" | "justify" | "justify-last-line" | "child-spacing" | "line-spacing" | "orientation" | "wrap-policy" | "child-spacing-unit" | "natural-line-length" | "pack-direction" | "wrap-reverse" | "line-spacing-unit" | "line-homogeneous" | "natural-line-length-unit")[];
+    /** Spacing between children on the same line, in `child-spacing-unit`. */
     get childSpacing(): number;
     set childSpacing(value: number);
-    /** Spacing between lines, in px (CSS row-gap). */
+    /** The unit `child-spacing` is written in. Defaults to `px`, as in C. */
+    get childSpacingUnit(): AdwLengthUnit;
+    set childSpacingUnit(value: AdwLengthUnit);
+    /** Spacing between lines, in `line-spacing-unit`. */
     get lineSpacing(): number;
     set lineSpacing(value: number);
+    /** The unit `line-spacing` is written in. Defaults to `px`, as in C. */
+    get lineSpacingUnit(): AdwLengthUnit;
+    set lineSpacingUnit(value: AdwLengthUnit);
+    /** Where the children sit ALONG the line (main axis): 0 start, 0.5 middle, 1 end. */
+    get align(): number;
+    set align(value: number);
+    /** Whether and how each line is stretched to fill the widget. */
+    get justify(): 'none' | 'fill' | 'spread';
+    set justify(value: 'none' | 'fill' | 'spread');
+    /** Whether the FINAL line is justified too. Default false, as in C. */
+    get justifyLastLine(): boolean;
+    set justifyLastLine(value: boolean);
+    /** Whether an overflowing line squeezes its children or lets them spill. */
+    get wrapPolicy(): 'minimum' | 'natural';
+    set wrapPolicy(value: 'minimum' | 'natural');
+    /** The direction children are packed in each line. */
+    get packDirection(): 'start-to-end' | 'end-to-start';
+    set packDirection(value: 'start-to-end' | 'end-to-start');
+    /** Whether lines wrap upwards (horizontal) / towards the start (vertical). */
+    get wrapReverse(): boolean;
+    set wrapReverse(value: boolean);
+    /** Whether every line takes the same amount of space. */
+    get lineHomogeneous(): boolean;
+    set lineHomogeneous(value: boolean);
+    /** The natural line length in `natural-line-length-unit`, or `-1` when unset. */
+    get naturalLineLength(): number;
+    set naturalLineLength(value: number);
+    /** The unit `natural-line-length` is written in. Defaults to `px`, as in C. */
+    get naturalLineLengthUnit(): AdwLengthUnit;
+    set naturalLineLengthUnit(value: AdwLengthUnit);
+    /** The axis children are packed along. */
+    get orientation(): 'horizontal' | 'vertical';
+    set orientation(value: 'horizontal' | 'vertical');
+    /** The element children, which are what the layout actually lays out. */
+    private get _children();
+    /**
+     * `adw_wrap_box_insert_child_after` (adw-wrap-box.c:1283-1300).
+     *
+     * A NULL/absent `sibling` inserts at the FIRST position, not the last —
+     * `gtk_widget_insert_after`'s documented rule, pinned by
+     * `WRAP_BOX_CHILD_ORDER_VECTORS`. Returns whether the insert happened; a
+     * refusal is where C would have hit a `g_return_if_fail`.
+     */
+    insertChildAfter(child: Element, sibling?: Element | null): boolean;
+    /** `adw_wrap_box_reorder_child_after` (adw-wrap-box.c:1315-1332). Same NULL rule. */
+    reorderChildAfter(child: Element, sibling?: Element | null): boolean;
+    /** `adw_wrap_box_remove_all` (adw-wrap-box.c:1406-1414). */
+    removeAll(): void;
+    private _applyOrder;
     connectedCallback(): void;
     attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    /** One attribute's value as the widget stores it — the notify comparison key. */
+    private _normalized;
     private _sync;
 }

package/lib/types/elements/view-switcher-dom.d.ts

@@ -0,0 +1,44 @@
+import type { AdwViewSwitcherPageInit, ViewSwitcherScheduler } from '@gjsify/adwaita-core';
+import { type AdwIcon } from './adw-icon.js';
+/**
+ * The browser's timer behind the core's scheduler seam.
+ *
+ * One shared instance rather than one per element: it holds no state, and the
+ * seam exists so the CORE stays free of a global timer, not so each element
+ * invents its own.
+ */
+export declare const domViewSwitcherScheduler: ViewSwitcherScheduler;
+/**
+ * Build a switcher button's icon node, carrying its own position class.
+ *
+ * The core resolves NULL/empty to `image-missing` (which the stylesheet carries
+ * a real glyph for); the `-symbolic` strip and the CSS-token guard are
+ * `normalizeIconName`'s, applied by `<adw-icon>` — that strip is this package's
+ * own mask-class convention and has no counterpart in C, where the name reaches
+ * `GtkImage` untouched.
+ */
+export declare function createSwitcherIcon(iconName: string, extra: string): AdwIcon;
+/** Repaint an existing switcher icon from a page's declared name. */
+export declare function applySwitcherIcon(icon: AdwIcon, iconName: string): void;
+/**
+ * Read a declared page element into the core's page init.
+ *
+ * `getAttribute` returns `null` for an absent attribute, which is EXACTLY C's
+ * NULL — so the values are passed through unchanged rather than defaulted to
+ * `''`. That `?? ''` is what made the button-visibility rule unimplementable in
+ * the old code: once an absent title has become the empty string, "the page has
+ * no title" is no longer expressible.
+ */
+export declare function readSwitcherPage(element: Element): AdwViewSwitcherPageInit;
+/**
+ * Paint `AdwIndicatorBin`'s badge/dot onto a span: the badge text when there is
+ * one, a bare dot when only `needs-attention` is set, nothing otherwise
+ * (adw-indicator-bin.c:58-68 + the `.needs-attention` style class).
+ */
+export declare function applyIndicator(indicator: HTMLElement, badgeLabel: string, needsAttention: boolean): void;
+/**
+ * Mirror the derived screen-reader description onto the element, REMOVING the
+ * attribute when there is none — `update_description_cb` resets the accessible
+ * property rather than setting it to `""` (adw-view-switcher-button.c:104-113).
+ */
+export declare function applyDescription(element: HTMLElement, description: string): void;

package/lib/types/entry-rows.spec.d.ts

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

package/lib/types/index.d.ts

@@ -1,4 +1,5 @@
 import '@gjsify/adwaita-fonts';
+export { addBreakpoints, bindBreakpointSetter } from './breakpoints.js';
 export { AdwAvatar } from './elements/adw-avatar.js';
 export { AdwBanner } from './elements/adw-banner.js';
 export { AdwCard } from './elements/adw-card.js';
@@ -12,6 +13,12 @@ export { AdwHeaderBar } from './elements/adw-header-bar.js';
 export { AdwWindowTitle } from './elements/adw-window-title.js';
 export { AdwButton } from './elements/adw-button.js';
 export { AdwButtonContent } from './elements/adw-button-content.js';
+export { AdwIcon, createAdwIcon } from './elements/adw-icon.js';
+export { AdwSwitch } from './elements/adw-switch.js';
+export { AdwCheckbox, AdwRadio } from './elements/adw-checks.js';
+export { AdwProgressBar } from './elements/adw-progress-bar.js';
+export { AdwPopover } from './elements/adw-popover.js';
+export type { AdwPopoverAlign, AdwPopoverPosition, AdwPopoverRole } from './elements/adw-popover.js';
 export { AdwSplitButton } from './elements/adw-split-button.js';
 export { AdwToggle, AdwToggleGroup } from './elements/adw-toggle-group.js';
 export { AdwEntry } from './elements/adw-entry.js';

package/lib/types/navigation-view.spec.d.ts

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

package/lib/types/preferences-search.d.ts

@@ -0,0 +1,20 @@
+import { type PreferencesSearchPage, type PreferencesSearchResult, type SearchPreferencesOptions } from '@gjsify/adwaita-core';
+/**
+ * Describe every `<adw-preferences-page>` under `root` as the tree
+ * `searchPreferences` indexes.
+ *
+ * Page identity is read off the element itself — which is why the dialog keeps
+ * the page elements in its subtree instead of hoisting their children out. A
+ * flattened dialog has no page titles, and `create_search_row_subtitle` needs
+ * them the moment a second page exists.
+ */
+export declare function describePreferencesPages(root: ParentNode): PreferencesSearchPage<Element>[];
+/**
+ * Search the preferences pages under `root`, returning the result rows a
+ * `search_results` list box would be bound to.
+ *
+ * Each result carries the `<adw-preferences-page>` and the row element, so a
+ * caller can reproduce `search_result_activated_cb`: reveal the page, focus
+ * the row.
+ */
+export declare function searchPreferencesDom(root: ParentNode, query: string, options?: SearchPreferencesOptions): PreferencesSearchResult<Element>[];

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

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

package/lib/types/split-button.spec.d.ts

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

package/lib/types/split-views.spec.d.ts

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