@gjsify/adwaita-web 0.32.0 → 0.33.0

package/lib/types/elements/adw-combo-row.d.ts

@@ -11,5 +11,15 @@ export declare class AdwComboRow extends HTMLElement {
     set selected(value: number);
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * `model_changed` (adw-combo-row.c:187-195) — one option or none is not a
+     * choice, so the arrow goes and the row stops being activatable.
+     *
+     * Both halves have to be expressed: `data-presents-chooser` gates the
+     * `.adw-row-value::after` mask in the stylesheet, and DISABLING the overlaid
+     * `<select>` is what makes the row inert — hiding the arrow alone would leave
+     * a row that still opens a one-entry popup on click.
+     */
+    private _syncChooser;
     private _renderText;
 }

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

@@ -1,16 +1,33 @@
+import type { ViewSwitcherScheduler } from '@gjsify/adwaita-core';
 import type { AdwInlineViewSwitcherDisplayMode, AdwViewSwitcherPage } from '@gjsify/adwaita-core';
 /** A single page. Children of <adw-inline-view-switcher>; consumed at connect time. */
 export declare class AdwViewStackPage extends HTMLElement {
     static get observedAttributes(): string[];
 }
 export declare class AdwInlineViewSwitcher extends HTMLElement {
-    private readonly _state;
+    /**
+     * 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 _groupEl;
     private _pagesEl;
     private _panels;
     private _toggles;
     private _displayMode;
     private _initialized;
+    /** The page ELEMENTS, kept because this element detaches them from the tree. */
+    private _declared;
+    private _pageObserver;
     static get observedAttributes(): string[];
     constructor();
     /** Zero-based index of the visible PAGE, `-1` when nothing is selected. */
@@ -39,6 +56,25 @@ export declare class AdwInlineViewSwitcher extends HTMLElement {
     setPageVisible(name: string, visible: boolean): boolean;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /**
+     * Re-read every declared page and push it into the state.
+     *
+     * Driven by {@link _watchPages}, which is what makes a runtime
+     * `badge-number` or `icon-name` change reach the toggle — C rebinds on every
+     * page `notify` (adw-view-switcher.c:184-193) and this element did not.
+     */
+    refreshPages(): void;
+    /**
+     * Watch the declared pages for attribute changes — the DOM's `notify::` on
+     * `AdwViewStackPage`, which C binds per page (adw-view-switcher.c:184-193).
+     *
+     * A `MutationObserver` rather than an `attributeChangedCallback`: this
+     * element consumes the page elements at connect and `replaceChildren`s them
+     * out of the tree, so a detached page cannot find its owner. It delivers on
+     * a MICROTASK where GTK's notify is synchronous — invisible to a user, and
+     * nothing here reads the toggle back inside the setter.
+     */
+    private _watchPages;
     attributeChangedCallback(name: string): void;
     private _readDisplayModeAttr;
     /**

package/lib/types/elements/adw-navigation-split-view.d.ts

@@ -1,20 +1,62 @@
+import { type AdwPackType, type NavigationActionResult } from '@gjsify/adwaita-core';
+/** Detail of the `navigation-push` / `navigation-pop` delegation event. */
+export interface NavigationDelegateDetail {
+    /** The tag a `push` names; absent for a `pop`. */
+    tag?: string;
+    /** Set by an ancestor that handled it — the `return TRUE` of the C's routing. */
+    handled: boolean;
+}
 export declare class AdwNavigationSplitView extends HTMLElement {
     private _sidebarEl;
     private _contentEl;
     private _initialized;
     private _disposeBreakpoint;
+    /** The ordering table, the tag guard and the action routing (ADR 0004). */
+    private _state;
+    /** Re-entrancy guard for the `show-content` reflection. */
+    private _reflecting;
     static get observedAttributes(): string[];
     get collapsed(): boolean;
     set collapsed(v: boolean);
     /** When collapsed, whether the content pane (true) or sidebar (false) shows. */
     get showContent(): boolean;
     set showContent(v: boolean);
+    /** Which side the sidebar is packed on — `start` (default) or `end`. */
+    get sidebarPosition(): AdwPackType;
+    set sidebarPosition(value: AdwPackType);
+    /** The sidebar page's tag of record, or `null`. */
+    get sidebarTag(): string | null;
+    /** The content page's tag of record, or `null`. */
+    get contentTag(): string | null;
+    /**
+     * `navigation.push` with `tag` — `navigation_push_cb` (:644-685).
+     *
+     * An unmatched tag DELEGATES to the parent before it may become a critical,
+     * which is how nested split views forward a push outwards; on this port that
+     * is a bubbling `navigation-push` event whose `detail.handled` an ancestor
+     * sets. Returns what the routing decided.
+     */
+    push(tag: string): NavigationActionResult;
+    /** `navigation.pop` — `navigation_pop_cb` (:687-702). */
+    pop(): NavigationActionResult;
     connectedCallback(): void;
+    /** `Adw.NavigationPage:tag` off the slotted pane, or `null` when untagged. */
+    private _tagOf;
+    /**
+     * Mirror the state's `showContent` onto the attribute, so the DOM keeps
+     * telling the truth after a `navigation.push` moved it.
+     *
+     * Guarded the way the overlay view's reflection is: writing the attribute
+     * re-enters `attributeChangedCallback`, which without the flag is a loop.
+     */
+    private _reflectShowContent;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string): void;
     private _syncWidth;
     /** A pixel attribute, falling back to the widget's own default. */
     private _widthAttr;
+    /** The reading direction `start` / `end` resolve against (`get_start_or_end`, :220-227). */
+    private get _direction();
     private _syncClasses;
     /** (Re)bind the `breakpoint` condition to `collapsed`. */
     private _syncBreakpoint;

package/lib/types/elements/adw-overlay-split-view.d.ts

@@ -13,6 +13,13 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     private _state;
     /** Re-entrancy guard for {@link _reflectShowSidebar}. */
     private _reflecting;
+    /** The view's own width in CSS px — the size the sidebar fraction is OF. */
+    private _measuredWidth;
+    private _resizeObserver;
+    /** The pointer currently panning the sidebar, if any. */
+    private _swipePointer;
+    /** Where the pan started, and the progress it started from. */
+    private _swipeOrigin;
     /**
      * Every attribute {@link _readAttribute} handles must be listed here — an
      * unobserved attribute never reaches `attributeChangedCallback`, so its branch
@@ -29,7 +36,23 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     get maxSidebarWidth(): number;
     get sidebarWidthFraction(): number;
     connectedCallback(): void;
+    /** The DOM surgery and the state, which happen once per element lifetime. */
+    private _buildOnce;
+    /**
+     * Everything that must be re-established every time the element enters a
+     * document — NOT once per lifetime.
+     *
+     * `connectedCallback` returns early on the second connect (the DOM is
+     * already built), so anything torn down in `disconnectedCallback` used to be
+     * gone for good: moving the view between parents — which is what a slideshow
+     * or a client-side route change does — killed the ResizeObserver and left
+     * `_measuredWidth` frozen at whatever it last saw, or at 0 if the view had
+     * never been visible. That is the other half of the docs-site regression.
+     */
+    private _bindToDocument;
     disconnectedCallback(): void;
+    /** `escape_shortcut_cb` — only a COLLAPSED view with a revealed sidebar consumes it. */
+    private readonly _onKeyDown;
     attributeChangedCallback(_name: string, _old: string | null, _val: string | null): void;
     /**
      * Push ONE attribute into the state, then reflect back what the state made
@@ -54,6 +77,39 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     openSidebar(): void;
     hideSidebar(): void;
     toggleSidebar(): void;
+    /**
+     * The reading direction `start` / `end` are resolved against.
+     *
+     * `get_start_or_end` (adw-overlay-split-view.c:227-234) returns
+     * `GTK_PACK_END` under RTL, so a `start` sidebar is drawn on the RIGHT.
+     * Neither renderer mirrored any of it; the browser has the direction for
+     * free and only had to read it.
+     */
+    private get _direction();
+    /** The sizing properties as the core takes them. */
+    private get _widthSpec();
+    /** The sidebar's allocated width in px — `get_sidebar_width` (:441-466). */
+    private get _sidebarWidth();
     private _syncClasses;
+    /**
+     * Place the sidebar for the current progress — `allocate_uncollapsed`
+     * (:572-610) and `allocate_collapsed` (:653-703), through the core.
+     *
+     * The slide used to be `marginRight: -offsetWidth` REGARDLESS of which edge
+     * the sidebar is on, so an `end` sidebar slid the wrong way; and it was only
+     * two states, so a swipe had nothing to drive. `layoutOverlaySplitView`
+     * returns the pane rect for any progress including the overshoot, which is
+     * what makes a continuous gesture expressible at all.
+     */
+    private _syncGeometry;
     private _syncSidebarWidth;
+    /**
+     * The pan gesture the five `OVERLAY_SWIPE_*` tables describe.
+     *
+     * There was no gesture code in either renderer — grep for `pan` in both
+     * split views returned zero — so `showProgress` was only ever 0 or 1 and the
+     * tables shipped unexercised. Pointer events give the browser the whole
+     * gesture in three handlers; every DECISION in them is core's.
+     */
+    private _bindSwipe;
 }

package/lib/types/elements/adw-spinner.d.ts

@@ -1,6 +1,29 @@
 export declare class AdwSpinner extends HTMLElement {
     static get observedAttributes(): string[];
+    private _svg;
+    private _track;
+    private _arc;
+    /** Path length of the ring, so the dash arithmetic is done once per resize. */
+    private _circumference;
+    /** Ring radius in px — the dash lengths are arc-length, i.e. radians × r. */
+    private _radius;
+    /** The timestamp this spinner was mapped at, so its progress starts at 0. */
+    private _origin;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
+    /**
+     * Draw the frame for `now`, in `requestAnimationFrame` timebase.
+     *
+     * Public because the shared ticker is a module-level function rather than a
+     * method — and because a test needs to place the spinner at a known moment
+     * without waiting for real frames.
+     */
+    drawAt(now: number): void;
+    private _build;
+    /** Re-derive the box, the ring and the stroke from the `size` attribute. */
     private _sync;
+    /** The progress the last painted frame used, so a resize can repaint it. */
+    private _lastProgress;
+    private _paint;
 }

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

@@ -39,6 +39,18 @@ export declare class AdwViewStack extends HTMLElement {
      * (`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

@@ -26,11 +26,13 @@ export declare class AdwViewSwitcherBar extends HTMLElement {
     /** Bind to a stack element (or null). Unbinds the previous one and rebuilds. */
     setStack(stack: AdwViewStack | null): void;
     /**
-     * Rebuild the buttons — needed after pages were added to the bound stack
-     * WITHOUT changing its selection. A page add that does move the selection
-     * (the first one) notifies and rebuilds on its own. libadwaita rebuilds on
-     * the pages model's `items-changed` (adw-view-switcher.c:258-263), which the
-     * DOM stack has no counterpart for yet.
+     * 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;

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

@@ -1,13 +1,42 @@
+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. */
+/**
+ * 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 {
-    private readonly _state;
+    /**
+     * 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 _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[];
@@ -31,6 +60,29 @@ export declare class AdwViewSwitcher extends HTMLElement {
     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;

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;
 }