@gjsify/adwaita-web 0.31.0 → 0.33.0

package/lib/types/adw-about-dialog.spec.d.ts

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

package/lib/types/adw-action-rows.spec.d.ts

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

package/lib/types/adw-avatar.spec.d.ts

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

package/lib/types/adw-banner.spec.d.ts

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

package/lib/types/adw-button-content.spec.d.ts

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

package/lib/types/adw-carousel.spec.d.ts

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

package/lib/types/adw-checks.spec.d.ts

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

package/lib/types/adw-header-bar.spec.d.ts

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

package/lib/types/adw-icon.spec.d.ts

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

package/lib/types/adw-progress-bar.spec.d.ts

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

package/lib/types/adw-sidebar.spec.d.ts

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

package/lib/types/adw-switch.spec.d.ts

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

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

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

package/lib/types/bottom-sheet.spec.d.ts

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

package/lib/types/breakpoints.d.ts

@@ -0,0 +1,22 @@
+import { AdwBreakpoint } from '@gjsify/adwaita-core';
+/**
+ * Drive `breakpoints` from `element`'s own box, and return a dispose function.
+ *
+ * `ResizeObserver` delivers an initial observation on `observe()`, so the
+ * breakpoints settle on the correct state before first paint — no flash of the
+ * wrong layout, and no separate seeding pass.
+ *
+ * The size read is the BORDER box in CSS pixels, the browser's counterpart to
+ * the `sp`/DIP units an Adwaita condition is written in.
+ */
+export declare function addBreakpoints(element: Element, breakpoints: readonly AdwBreakpoint[]): () => void;
+/**
+ * Wire a `breakpoint="<condition>"` attribute to a boolean setter, the browser
+ * equivalent of an `Adw.Breakpoint` with one `add_setter()` call.
+ *
+ * Returns a dispose function; call it before re-binding and on disconnect.
+ * A missing or unparsable condition binds nothing and returns a no-op, leaving
+ * whatever the attribute already says untouched — an element must not silently
+ * flip state because its condition had a typo.
+ */
+export declare function bindBreakpointSetter(element: Element, condition: string | null, setValue: (active: boolean) => void): () => void;

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

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

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

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

package/lib/types/elements/adw-about-dialog.d.ts

@@ -51,24 +51,63 @@ export declare class AdwAboutDialog extends HTMLElement {
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     /** Reflect the presented state onto the host + reset the navigation stack. */
     private _syncOpen;
+    /** The credit groups the Credits page shows, straight from `update_credits`. */
+    private _creditsSections;
+    /**
+     * Whether the Legal page has anything on it.
+     *
+     * This element's licence model is the simplified one — a name plus an
+     * optional URL — so it maps onto `GtkLicense` as "custom text when a licence
+     * is set, unknown otherwise", which is what `adw_about_dialog_set_license`
+     * does to the type anyway (:3472).
+     */
+    private _hasLegal;
     /** Rebuild the sheet contents from the current attributes / credit lists. */
     private _render;
-    /** A navigation page wrapping a header bar (with the close button) + content. */
+    /**
+     * A navigation page wrapping a header bar (with the close button) + content.
+     *
+     * `headerTitle` defaults to the page title; the main page overrides it,
+     * because its page title is the dialog's ("About", .ui:19) while its header
+     * shows the application name (.ui:30).
+     */
     private _buildPage;
-    /** The main page: icon, name, developer, version pill, navigation rows. */
+    /** The main page: icon, name, developer, version pill, then the three groups. */
     private _buildMainPage;
+    /**
+     * One `AdwPreferencesGroup` in its spacing wrapper.
+     *
+     * `data-group` carries the template's widget id so a test — and a reader —
+     * can tell the four named groups apart; nothing styles off it. The credits
+     * sections pass `null`, because the template has no id for them: they are
+     * built one per section at runtime (:548-549).
+     */
+    private _buildGroup;
     /** An activatable row that pushes a subpage, with a trailing go-next chevron. */
     private _buildNavRow;
-    private _hasDetails;
-    private _hasCredits;
-    private _hasLegal;
-    /** The Details page: comments + website / support / issue link rows. */
+    /**
+     * Emit `activate-link` and navigate unless a handler took over.
+     *
+     * The GObject signal is `BOOLEAN__STRING` with `g_signal_accumulator_true_handled`
+     * (:2093-2103) and its default handler returns `GDK_EVENT_PROPAGATE`
+     * (:455-460), i.e. "not handled, do the default". A handler returning TRUE
+     * suppresses it — which is what `preventDefault()` on a cancelable event
+     * means, and why `dispatchEvent`'s return value is the gate here.
+     */
+    private _activateLink;
+    /** The Details page: comments + the links group (website + future custom links). */
     private _buildDetailsPage;
     /** A link row that opens a URL in a new tab and emits `activate-link`. */
     private _buildLinkRow;
-    /** The Credits page: a group per non-empty credit section. */
+    /** The Credits page: one group per section the core assembled. */
     private _buildCreditsPage;
-    /** A credit row — a plain title, or a link row when the entry carries a URI. */
+    /**
+     * A credit row — a plain title, or a link row when the entry carries a URI.
+     *
+     * The gate is `link !== null`, not the URI's truthiness: `"Ada <>"` parses to
+     * an EMPTY link, which is still a link in the C (`if (link)` tests the
+     * pointer, :562) and still produces an `AdwLinkRow`, to `mailto:`.
+     */
     private _buildCreditRow;
     /** The Legal page: copyright + license text. */
     private _buildLegalPage;

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

@@ -3,13 +3,48 @@ export declare class AdwActionRow extends HTMLElement {
     private _subtitleEl;
     private _suffixEl;
     private _prefixEl;
+    /** The headless labels + activatable-widget coupling (ADR 0004). */
+    private readonly _state;
+    /** Watches the activatable widget's `disabled`/`aria-disabled` — the live binding. */
+    private _sensitivityObserver;
     private _initialized;
     static get observedAttributes(): string[];
     /** The end (suffix) section — append controls here imperatively. */
     get suffixSection(): HTMLDivElement;
     /** The start (prefix) section — append icons/widgets here imperatively. */
     get prefixSection(): HTMLDivElement;
+    /** `Adw.ActionRow:activatable-widget` — the widget this row activates. */
+    get activatableWidget(): HTMLElement | null;
+    /**
+     * Set the activatable widget. Its sensitivity is copied into `activatable`
+     * right away and then tracked, exactly as libadwaita's `sensitive` →
+     * `activatable` binding does (adw-action-row.c:729-732) — including the part
+     * that surprises: clearing the widget LEAVES the row activatable (C:709).
+     */
+    set activatableWidget(widget: HTMLElement | null);
+    /** Whether a click activates this row — `GtkListBoxRow:activatable`. */
+    get activatable(): boolean;
     connectedCallback(): void;
+    /** Copy the declarative attributes into the headless state. */
+    private _adoptAttributes;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
+    /**
+     * `adw_action_row_activate_real` (adw-action-row.c:297-307): forward the
+     * activation to the activatable widget, then emit `activated`.
+     *
+     * A click that ORIGINATED inside the activatable widget does not activate the
+     * row at all — no forwarding, no `activated`. That is GTK's answer too: the
+     * widget claims the gesture, so `GtkListBox` never emits `row-activated`, and
+     * `pressed_cb` denies anything picked below the row / header / prefixes /
+     * suffixes (C:120-137). It is also what keeps the forwarding from looping —
+     * the synthetic click dispatched below bubbles straight back into this same
+     * listener, and without the guard one activation emitted `activated` twice.
+     */
+    private _onClick;
+    /** (Re)point the sensitivity watcher at `widget`, or stop watching. */
+    private _observeSensitivity;
+    /** Reflect the state's `activatable` back onto the attribute + class. */
+    private _syncActivatable;
     private _render;
 }

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

@@ -6,4 +6,15 @@ export declare class AdwAvatar extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(): void;
     private _render;
+    /**
+     * Size the initials the way `update_font_size` does: measure the label, then
+     * scale its aspect ratio against the cap.
+     *
+     * Only the ratio matters and it is font-size invariant, so measuring AT the
+     * cap is the browser's equivalent of Pango's reset-then-measure. The old
+     * `size * (size < 32 ? 0.5 : 0.4)` guess overflowed that cap at sizes 28, 30,
+     * 31 and everything from 64 up — the initials spilled out of the circle —
+     * and was not monotonic across the 32px boundary.
+     */
+    private _applyFontSize;
 }

package/lib/types/elements/adw-bottom-sheet.d.ts

@@ -1,3 +1,4 @@
+import type { BottomSheetCloseOutcome, BottomSheetCloseSource } from '@gjsify/adwaita-core';
 /** The persistent content. Child of <adw-bottom-sheet>; consumed at connect time. */
 export declare class AdwBottomSheetContent extends HTMLElement {
 }
@@ -10,6 +11,10 @@ export declare class AdwBottomSheet extends HTMLElement {
     private _dimmingEl;
     private _sheetEl;
     private _dragHandleEl;
+    /** The shared open/can-close model — the single source of truth for both. */
+    private readonly _state;
+    /** Set while the element writes `open` back, so the write does not re-enter. */
+    private _reflecting;
     static get observedAttributes(): string[];
     /** Whether the sheet is revealed. */
     get open(): boolean;
@@ -17,19 +22,43 @@ export declare class AdwBottomSheet extends HTMLElement {
     /** Whether the content is dimmed + blocked while the sheet is open. */
     get modal(): boolean;
     set modal(value: boolean);
-    /** Whether the user can dismiss the sheet (handle / dimming / Escape). */
+    /** Whether the user can dismiss the sheet (dimming / Escape / sheet.close). */
     get canClose(): boolean;
     set canClose(value: boolean);
     /** Whether the overlaid drag handle is shown. */
     get showDragHandle(): boolean;
     set showDragHandle(value: boolean);
+    /**
+     * Route a dismissal affordance through the shared gate and act on the
+     * verdict: close, raise `close-attempt`, forward `sheet.close` to an
+     * ancestor, or do nothing. The element calls this for the dimming layer and
+     * Escape; a close button inside the sheet calls it with `'close-button'`.
+     *
+     * The verdict differs per source — a locked sheet signals a scrim click but
+     * swallows a swipe, and the drag handle never closes anything. See
+     * `resolveBottomSheetClose` in `@gjsify/adwaita-core`.
+     */
+    requestClose(source: BottomSheetCloseSource): BottomSheetCloseOutcome;
     connectedCallback(): void;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    private _attemptClose;
+    /** The programmatic open/close — `AdwBottomSheet:open`, ungated by `can-close`. */
+    private _setOpen;
     private _render;
-    /** Read a boolean attribute that defaults to `true` when absent. */
+    /** Mirror the state onto the `open` attribute (the CSS + markup hook). */
+    private _reflectOpen;
+    /** Read a boolean attribute: absent → `fallback`, explicit `="false"` → off. */
     private _boolAttr;
     private _setBoolAttr;
-    /** Move declared slot children out of the light-DOM tree into a list. */
+    /**
+     * Collect the nodes declared for one slot, in DOCUMENT order, marking every
+     * consumed child in `claimed`.
+     *
+     * The `<adw-bottom-sheet-sheet>` / `<adw-bottom-sheet-content>` wrappers are
+     * markup, not widgets — GtkBuilder's `<child type="sheet">` leaves nothing in
+     * the tree (adw-bottom-sheet.c:1278-1293) — so the wrapper itself is claimed
+     * too. It used to fall through to `unslotted` and be appended to the content
+     * layer, leaving an empty custom element behind after its children were
+     * pulled out.
+     */
     private _collectSlot;
 }

package/lib/types/elements/adw-button-content.d.ts

@@ -3,8 +3,20 @@ export declare class AdwButtonContent extends HTMLElement {
     private _iconEl;
     private _labelEl;
     private _initialized;
+    /** The node currently carrying `image-text-button`, so unroot can find it. */
+    private _styledHost;
     static get observedAttributes(): string[];
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /**
+     * `adw_button_content_root` (:108-116): the nearest button ancestor, unless
+     * that button's DIRECT parent is a split button — then the split button
+     * takes the class, because `splitbutton.image-text-button > button` is the
+     * rule that styles it (_buttons.scss:499-507).
+     */
+    private _hostButton;
+    private _root;
+    private _unroot;
     private _render;
 }

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

@@ -1,11 +1,20 @@
 export declare class AdwButtonRow extends HTMLElement {
     private _contentsEl;
     private _startIconEl;
+    private _endIconEl;
     private _titleEl;
+    /** The headless title + start/end icon state (ADR 0004). */
+    private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];
     connectedCallback(): void;
     attributeChangedCallback(): void;
-    private _isActivatable;
     private _render;
+    /**
+     * Paint one of the two `image.icon.{start,end}` nodes (adw-button-row.c:39-40).
+     *
+     * The `start` / `end` position class is set once at construction — it is
+     * where the node sits, not what it draws — so only the name changes here.
+     */
+    private _paintIcon;
 }

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

@@ -2,38 +2,140 @@
 interface CarouselHost extends HTMLElement {
     readonly nPages: number;
     readonly position: number;
+    /** The page the current position settles on, `-1` when empty. */
+    readonly currentPage: number;
     scrollToPage(index: number): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
 }
 export declare class AdwCarousel extends HTMLElement implements CarouselHost {
+    private readonly _state;
     private _trackEl;
-    private _pages;
-    private _position;
+    /** Page id → its `.adw-carousel-page` slot. Ids are internal; the DOM node is the public handle. */
+    private readonly _slots;
+    private _nextPageId;
     private _scrollRaf;
-    private _wheelAccum;
     private _initialized;
+    /** A declared `position` waiting for the track to have a width. */
+    private _pendingPosition;
+    private _pendingLayout;
+    /**
+     * `interactive` for the scroll now in flight: the flag of the request that
+     * started it, or `null` for a scroll we did not start — which is a user drag,
+     * and therefore interactive.
+     */
+    private _pendingInteractive;
     static get observedAttributes(): string[];
+    constructor();
     /** Number of pages in the carousel. */
     get nPages(): number;
     /** Fractional scroll position (0 = first page, 1 = second, …). */
     get position(): number;
+    /**
+     * Scroll to the page this position settles on.
+     *
+     * `AdwCarousel:position` is READ-ONLY in C (adw-carousel.c:1036-1041) — the
+     * setter is a port convenience, and it resolves the value with the same
+     * `get_page_at_position` rule the carousel uses everywhere else, so setting
+     * 0.5 lands on page 0 exactly as scrolling there would.
+     */
     set position(value: number);
-    /** Whether the scroll wheel navigates between pages. */
+    /** The page the current position settles on, `-1` when the carousel is empty. */
+    get currentPage(): number;
+    /** Whether the scroll wheel navigates between pages. Defaults to TRUE, as in libadwaita. */
     get allowScrollWheel(): boolean;
     set allowScrollWheel(value: boolean);
-    /** Whether a single flick can skip more than one page. */
+    /** Whether a single flick may cross more than one page. */
     get allowLongSwipes(): boolean;
     set allowLongSwipes(value: boolean);
+    /** Whether the carousel can be navigated at all. Defaults to TRUE. */
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    /** Spacing between pages in px (`AdwCarousel:spacing`). */
+    get spacing(): number;
+    set spacing(value: number);
     connectedCallback(): void;
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
-    /** Scroll (snap) to the page at `index`, clamped to the valid range. */
+    disconnectedCallback(): void;
+    /** One attribute → one state property. Shared by the initial read and later changes. */
+    private _applyAttribute;
+    /**
+     * Scroll to `value`, waiting for the first layout when the track has no
+     * width yet.
+     *
+     * `connectedCallback` runs DURING insertion, so the track is still 0px wide
+     * and a scroll offset has nowhere to land — a declared
+     * `<adw-carousel position="2">` silently stayed on page 0. Deferring to the
+     * first non-zero measurement is the only point at which the offset means
+     * anything; a later assignment simply replaces the pending one.
+     */
+    private _positionWhenMeasurable;
+    /**
+     * Jump to `value` without the reveal animation.
+     *
+     * A DECLARED position is where the carousel STARTS, not somewhere it travels
+     * to — `<adw-carousel position="2">` should render already showing page 2.
+     * Left smooth, the track is still at offset 0 while the animation runs, and
+     * the `scroll` event that fires from there recomputes the position back to
+     * page 0. So the one assignment is made instant and the caller's
+     * `scroll-behavior` is put back.
+     */
+    private _scrollInstantly;
+    /** Drop a pending declared position and stop watching for a layout. */
+    private _cancelPendingPosition;
+    /** Resolve a fractional position to a page and scroll there; a no-op when there is none. */
+    private _scrollToPosition;
+    /**
+     * Insert `page` at `position` — `adw_carousel_insert` (adw-carousel.c:1370-1407).
+     * `-1` or a position past the end appends. Returns whether it was added.
+     */
+    insertPage(page: HTMLElement, position?: number): boolean;
+    /** `adw_carousel_append` (adw-carousel.c:1348-1357). */
+    appendPage(page: HTMLElement): boolean;
+    /** `adw_carousel_prepend` (adw-carousel.c:1330-1339). */
+    prependPage(page: HTMLElement): boolean;
+    /** Remove `page` — `adw_carousel_remove` (adw-carousel.c:1508-1532). */
+    removePage(page: HTMLElement): boolean;
+    /** Move `page` — `adw_carousel_reorder` (adw-carousel.c:1419-1499). */
+    reorderPage(page: HTMLElement, position: number): boolean;
+    /**
+     * Scroll to the page at `index`. Out-of-range, fractional and NaN indices are
+     * refused rather than clamped, matching `adw_carousel_get_nth_page`'s
+     * precondition (adw-carousel.c:1616).
+     */
     scrollToPage(index: number): void;
+    /** One keynav step — `navigate_to_direction` (adw-carousel.c:475-508). */
+    navigate(direction: 'back' | 'forward'): boolean;
+    private _insert;
+    /** The state's id for a page element, or `null` when it is not one of ours. */
+    private _idOf;
+    /** Make the DOM order match the model order, and drop slots whose page is gone. */
+    private _syncTrack;
+    /**
+     * Put the scroll offset back where the model says it is, instantly.
+     *
+     * A page revealed at or before the current one moves the position with it
+     * (`shift_position`, adw-carousel.c:241-258) precisely so the page on screen
+     * does not slide sideways — but a scroll container knows nothing about that
+     * and would keep its old offset, showing the newly-inserted page instead. GTK
+     * gets this for free because the same allocation that adds the child also
+     * lays it out; here it takes one write.
+     */
+    private _applyScrollFromModel;
+    /**
+     * `allow-long-swipes` in CSS: `scroll-snap-stop: always` forces the scroll to
+     * stop at every page, which is exactly what the property being FALSE means —
+     * "each swipe can only move to the adjacent pages" (adw-carousel.c:1111-1113).
+     */
+    private _applySnapStop;
+    /** The px pitch between two page origins — `self->distance` (adw-carousel.c:767). */
+    private _distance;
+    /** Run the scroll the state asked for, in the track's own scroll coordinates. */
+    private _performScroll;
     private _onScroll;
     private _onWheel;
     private _updatePositionFromScroll;
-    private _slotWidth;
-    private _emitPosition;
+    private _onStateChange;
 }
 /** Shared base for the dot / line indicator elements. */
 declare abstract class AdwCarouselIndicator extends HTMLElement {
@@ -52,6 +154,7 @@ declare abstract class AdwCarouselIndicator extends HTMLElement {
     private _onChange;
     protected nPages(): number;
     protected position(): number;
+    protected currentPage(): number;
     protected goTo(index: number): void;
     protected abstract _render(): void;
 }

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

@@ -0,0 +1,57 @@
+/** The markup + state shared by `<adw-checkbox>` and `<adw-radio>`. */
+declare abstract class AdwCheckBase extends HTMLElement {
+    protected _input: HTMLInputElement;
+    protected _indicator: HTMLSpanElement;
+    protected _label: HTMLSpanElement;
+    private _initialized;
+    /** `checkbox` or `radio` — the native control this element is built around. */
+    protected abstract get inputType(): 'checkbox' | 'radio';
+    /** What a click / Space / arrow key on the control means for this kind. */
+    protected abstract activate(): void;
+    /** Whether the control is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** Whether the control is in the third, inconsistent state. */
+    get indeterminate(): boolean;
+    set indeterminate(value: boolean);
+    /** Whether the control is inert. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** The label text beside the indicator. */
+    get label(): string;
+    set label(value: string);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /** Extra wiring for a subclass on connect. */
+    protected onConnected(): void;
+    /** Extra teardown for a subclass on disconnect. */
+    protected onDisconnected(): void;
+    protected render(): void;
+}
+/** The Adwaita checkbox — `checkbutton > check` as a custom element. */
+export declare class AdwCheckbox extends AdwCheckBase {
+    static get observedAttributes(): string[];
+    protected get inputType(): 'checkbox';
+    protected activate(): void;
+}
+/** The Adwaita radio — `checkbutton > radio`, exclusive within its `name`. */
+export declare class AdwRadio extends AdwCheckBase {
+    private _unsubscribe;
+    static get observedAttributes(): string[];
+    protected get inputType(): 'radio';
+    /** The group this member belongs to. */
+    get name(): string;
+    set name(value: string);
+    /**
+     * This member's value. Falls back to the label text so a group authored
+     * without values still has members the group state can tell apart.
+     */
+    get value(): string;
+    set value(value: string);
+    protected activate(): void;
+    protected onConnected(): void;
+    protected onDisconnected(): void;
+    protected render(): void;
+}
+export {};

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

@@ -1,6 +1,9 @@
 export declare class AdwClamp extends HTMLElement {
+    private _resize;
+    private _mutations;
     static get observedAttributes(): string[];
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
-    private _sync;
+    private _allocate;
 }

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-data-grid.d.ts

@@ -1,33 +1,5 @@
-/** Horizontal alignment of a column's header + cells. */
-export type AdwDataGridAlign = 'start' | 'end' | 'center';
-/** Accounting row emphasis. `normal` is the default plain data row. */
-export type AdwDataGridRowVariant = 'normal' | 'section' | 'subtotal' | 'total';
-/** A column descriptor — what to read (`key`), how to label + align it. */
-export interface AdwDataGridColumn {
-    /** The row-object key this column renders. */
-    key: string;
-    /** Header text (defaults to `key`). */
-    label?: string;
-    /** 'start' | 'end' | 'center'. Defaults to 'start' (or 'end' when numeric). */
-    align?: AdwDataGridAlign;
-    /** Fixed CSS track size (e.g. '80px', '6rem') — pins the column width. */
-    width?: string;
-    /** Fractional track weight (→ `<flex>fr`) — lets the column grow. */
-    flex?: number;
-    /** Render cells in a monospace family (tabular figures apply regardless). */
-    monospace?: boolean;
-    /** Convenience: right-align + tabular-nums (numeric columns of figures). */
-    numeric?: boolean;
-}
-/** A row: cell values keyed by column key + optional accounting metadata. */
-export interface AdwDataGridRow {
-    /** Accounting emphasis. Default 'normal'. */
-    variant?: AdwDataGridRowVariant;
-    /** Make just this row clickable (overrides the element-level flag). */
-    interactive?: boolean;
-    /** Cell values keyed by column key (pre-formatted strings, or numbers). */
-    [key: string]: string | number | boolean | AdwDataGridRowVariant | undefined;
-}
+import type { AdwDataGridColumn, AdwDataGridRow } from '@gjsify/adwaita-core';
+export type { AdwDataGridAlign, AdwDataGridCellValue, AdwDataGridColumn, AdwDataGridRow, AdwDataGridRowVariant, } from '@gjsify/adwaita-core';
 export declare class AdwDataGrid extends HTMLElement {
     private _captionEl;
     private _scrollEl;
@@ -52,7 +24,15 @@ export declare class AdwDataGrid extends HTMLElement {
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     private _parseJsonAttr;
     private _renderCaption;
-    /** The CSS `grid-template-columns` value derived from the column descriptors. */
+    /**
+     * The CSS `grid-template-columns` value derived from the column descriptors.
+     *
+     * The DERIVATION is core's (`dataGridTracks`), because NativeScript needs the
+     * same one for its `ItemSpec`s and can do nothing with a CSS string; the
+     * mapping onto CSS text — including the `minmax(0px, 1fr)` slack track whose
+     * `0px` must keep its unit to round-trip through the CSSOM — is
+     * `dataGridTrackTemplate`.
+     */
     private _trackTemplate;
     private _columnClasses;
     private _render;