@gjsify/adwaita-web 0.64.12-next.281 → 0.64.13-next.283

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

@@ -1,4 +1,4 @@
-import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
+import type { AdwComboOption, ComboWatchableModel } from '@gjsify/adwaita-core';
 import { TooltipElement } from '../widget-element.js';
 export declare class AdwComboRow extends TooltipElement {
     private _select;
@@ -9,19 +9,36 @@ export declare class AdwComboRow extends TooltipElement {
     private _subtitleEl;
     /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
     private readonly _state;
+    /**
+     * The list the MARKUP doors fill — the `model` ATTRIBUTE is JSON text and a
+     * `<gtk-string-list slot="model">` child is strings, and a real `Gio.ListModel` has no
+     * spelling in either (ADR 0122 § 5). Held for the element's whole life so re-parsing the
+     * attribute splices the list the element already points at rather than replacing it, which
+     * would reset the selection.
+     */
+    private readonly _authored;
     private _initialized;
     static get observedAttributes(): string[];
-    /** The list model (`Adw.ComboRow:model`). Setting it splices the <select> and clamps the selection. */
-    get model(): AdwComboOption[];
-    set model(value: AdwListModelInput);
+    /**
+     * The list model (`Adw.ComboRow:model`) — the OBJECT that was assigned, by identity, as
+     * `row.model === model` is measured to hold in libadwaita (ADR 0122 § 4). The normalised
+     * descriptors are {@link options}. Assigning splices the `<select>` and re-runs autoselect.
+     */
+    get model(): ComboWatchableModel | null;
+    set model(value: ComboWatchableModel | string | null);
+    /** The held model's items as `{ value, label }` descriptors. */
+    get options(): AdwComboOption[];
     /** `adw_combo_row_set_model`. */
-    set_model(model: AdwListModelInput | null): void;
+    set_model(model: ComboWatchableModel | null): void;
+    /** `adw_combo_row_get_model`. */
+    get_model(): ComboWatchableModel | null;
     /**
-     * The selected index (Adw.ComboRow:selected). PERMISSIVE: an index past the end is
-     * accepted and reads back with an empty {@link selectedValue}, mirroring the `guint`
-     * property that takes any position — where `<gtk-drop-down>` rejects the same set, as
-     * its own docs promise. `ComboState.hasIndex` owns the bounds and records why the
-     * POLICY is each renderer's; `COMBO_SELECTION_VECTORS` drives both answers.
+     * The selected index (Adw.ComboRow:selected). An index past the end is IGNORED — the
+     * selection stays where it was, which is what libadwaita is measured to do (ADR 0122 § 4,
+     * `combo-probe2.js`) and what `<gtk-drop-down>` already did. This element used to ACCEPT
+     * such a set and read back an empty {@link selectedValue}, the one row of
+     * `COMBO_SELECTION_VECTORS` the two selectors answered differently; the permissive half
+     * was ours, not GTK's, and it is gone. `ComboState.hasIndex` owns the bounds.
      */
     get selected(): number;
     set selected(value: number);
@@ -38,13 +55,15 @@ export declare class AdwComboRow extends TooltipElement {
     get selectedValue(): string;
     set selectedValue(value: string);
     /**
-     * The selected option descriptor, or `null` (Adw.ComboRow:selected-item).
+     * The selected ITEM, or `null` (Adw.ComboRow:selected-item).
      *
-     * Read-only, as the GObject property is. `null` and not a blank descriptor: the
-     * sentinel and an index past the end both address no option, and inventing an empty
-     * one would make "nothing is selected" indistinguishable from an option with no text.
+     * Read-only, as the GObject property is, and the MODEL'S OWN object rather than a
+     * descriptor, so the identity comparison a `selected-item` consumer writes holds (ADR
+     * 0122 § 4). `null` and not a blank item: the sentinel and an index past the end both
+     * address no option, and inventing an empty one would make "nothing is selected"
+     * indistinguishable from an option with no text.
      */
-    get selectedItem(): AdwComboOption | null;
+    get selectedItem(): unknown;
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     /**

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

@@ -32,6 +32,9 @@ export declare class AdwExpanderRow extends TooltipElement {
     get prefixSection(): HTMLDivElement;
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /** The `enable-expansion` attribute as a flag: on unless it says `false`. */
+    private _enableAttribute;
+    private _reflectExpanded;
     private _render;
     /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
     private _applyLineClamping;

package/lib/types/elements/gtk-drop-down.d.ts

@@ -1,5 +1,5 @@
 import './gtk-popover.js';
-import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
+import type { AdwComboOption, ComboWatchableModel } from '@gjsify/adwaita-core';
 import type { DispatchedSignals } from '../signals.js';
 import { WidgetElement } from '../widget-element.js';
 /**
@@ -19,13 +19,31 @@ export declare class GtkDropDown extends WidgetElement {
     private _itemButtons;
     /** The headless options list + selectedIndex↔selectedValue machine (ADR 0004). */
     private readonly _state;
+    /**
+     * The list the MARKUP doors fill — the `model` ATTRIBUTE is JSON text and a
+     * `<gtk-string-list slot="model">` child is strings, and a real `Gio.ListModel` has no
+     * spelling in either (ADR 0122 § 5). Held for the element's whole life so re-parsing the
+     * attribute splices the list the element already points at rather than replacing it, which
+     * would reset the selection.
+     */
+    private readonly _authored;
     private _initialized;
     private _typeAheadBuffer;
     private _typeAheadTimer;
     static get observedAttributes(): string[];
-    /** The list model (`Gtk.DropDown:model`). Setting it splices the popover and clamps the selection. */
-    get model(): GtkDropDownOption[];
-    set model(value: AdwListModelInput);
+    /**
+     * The list model (`Gtk.DropDown:model`) — the OBJECT that was assigned, by identity, as
+     * `dropdown.model === model` is measured to hold in GTK (ADR 0122 § 4). The normalised
+     * descriptors are {@link options}. Assigning splices the popover and re-runs autoselect.
+     */
+    get model(): ComboWatchableModel | null;
+    set model(value: ComboWatchableModel | string | null);
+    /** The held model's items as `{ value, label }` descriptors. */
+    get options(): AdwComboOption[];
+    /** `gtk_drop_down_set_model`. */
+    set_model(model: ComboWatchableModel | null): void;
+    /** `gtk_drop_down_get_model`. */
+    get_model(): ComboWatchableModel | null;
     /** The selected index. Out-of-range values are ignored (Gtk.DropDown:selected). */
     get selected(): number;
     set selected(value: number);
@@ -36,7 +54,15 @@ export declare class GtkDropDown extends WidgetElement {
     /** The selected option's value, or '' when empty (Gtk.DropDown:selected-item). */
     get selectedValue(): string;
     set selectedValue(value: string);
-    get selectedItem(): GtkDropDownOption | null;
+    /**
+     * The selected ITEM, or `null` (Gtk.DropDown:selected-item).
+     *
+     * The MODEL'S OWN object rather than a descriptor, so the identity comparison a
+     * `selected-item` consumer writes holds (ADR 0122 § 4).
+     */
+    get selectedItem(): unknown;
+    /** `gtk_drop_down_get_selected_item`. */
+    get_selected_item(): unknown;
     get enableSearch(): boolean;
     set enableSearch(value: boolean);
     get active(): boolean;

package/lib/types/elements/gtk-label.d.ts

@@ -1,4 +1,5 @@
 import { type LabelEllipsizeMode, type LabelJustification, type LabelWrapMode } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 import { WidgetElement } from '../widget-element.js';
 export declare class GtkLabel extends WidgetElement {
     /**
@@ -11,10 +12,45 @@ export declare class GtkLabel extends WidgetElement {
      * gets one text node").
      */
     private _wrapSpan;
+    /**
+     * The box the markup's runs are drawn in while the label is a SINGLE LINE — the case
+     * {@link _wrapSpan} does not cover, and the runs still may not go without a box.
+     *
+     * THE RUNS MAY NOT BE THE LABEL'S OWN CHILDREN. `gtk-label` is a flex container (the
+     * `xalign` spacers, `_labels.scss`), so each node directly under it is a FLEX ITEM —
+     * and a flex item is not text: `vertical-align` does not apply to one, so `<sup>` and
+     * `<sub>` stop being raised and lowered, and `align-items` centres each run on its own
+     * rather than the line sharing one baseline. A plain label never showed this because a
+     * bare text node is ONE anonymous item; a run list is as many items as it has runs. So
+     * the runs get a box and the box is the item. `null` while plain text is drawn, so a
+     * label without markup keeps the single text node `childElementCount` asserts on.
+     */
+    private _runSpan;
     private _resizes;
     /** Whether `_sync` last wrote `min-width` / `max-width` itself, and so may clear them. */
     private _wroteMinWidth;
     private _wroteMaxWidth;
+    /**
+     * The `<a href>` elements the label currently draws, in reading order.
+     *
+     * HELD ACROSS RENDERS because `visited` is: `gtk_label_set_markup` carries it over by
+     * URI (`labelLinksInheritVisited`), so a followed link stays followed when the text
+     * around it is rewritten. Empty whenever the markup has no links or does not parse.
+     */
+    private _links;
+    private _wired;
+    /**
+     * The inputs of the run list currently in the DOM, or `null` when plain text is.
+     *
+     * `_render` runs on EVERY observed attribute — `xalign` included — and rebuilding the
+     * run elements each time would drop a selection and the focus inside a link for a
+     * change that never touched the text. The plain-text path compares `textContent`; a
+     * list of elements has no such single string to compare against, so the two inputs
+     * that produced it stand in for it.
+     */
+    private _drawn;
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): ("label" | "use-markup" | "use-underline" | "justify" | "wrap" | "xalign" | "yalign" | "wrap-mode" | "ellipsize" | "lines" | "width-chars" | "max-width-chars" | "selectable")[];
     /** `Gtk.Label:label` — the text as written, before markup and the mnemonic come out. */
     get label(): string;
@@ -96,6 +132,34 @@ export declare class GtkLabel extends WidgetElement {
     private _normalized;
     private _render;
     private _renderSingleLine;
+    /**
+     * `render`'s runs — or `text` when there are none — into `target`.
+     *
+     * A PLAIN LABEL KEEPS ITS SINGLE TEXT NODE: `textContent` is still the whole of the
+     * write whenever there is no markup to draw, so the shape `gtk-label.spec.ts` asserts
+     * for the XSS answer (no elements at all) is unchanged for every label that does not
+     * ask for markup.
+     */
+    private _draw;
+    /**
+     * ONE delegated `click` listener, added once and never removed: the anchors are rebuilt
+     * on every render, so a listener per anchor would have to be re-added with them, and
+     * the element is the node they are always under.
+     */
+    private _wire;
+    private _click;
+    /**
+     * The launcher call, on its own method so a caller (or a spec) can stand in for the
+     * window the desktop would have opened — `<gtk-link-button>`'s `launch`, and the same
+     * door, because the two must not disagree about what following a link does.
+     */
+    protected launch(uri: string): void;
+    /**
+     * `visited` onto the anchors already in the DOM, rather than through a re-render: the
+     * link that was just clicked holds the focus, and rebuilding the runs under it would
+     * take that away for a change of one class.
+     */
+    private _paintVisited;
     /**
      * A WRAPPED OR ELLIPSIZED label centres its BLOCK by `xalign` (`gtklabel.c`,
      * `gtk_label_get_layout_location`), not just each line — `_labels.scss`'s two spacer

package/lib/types/label-markup.d.ts

@@ -0,0 +1,30 @@
+import { type LabelMarkupRender } from '@gjsify/adwaita-core';
+/**
+ * Which link an `<a>` draws, as its index into {@link LabelMarkupRender.links}.
+ *
+ * On the attribute and not in a JS-side map, because the element re-reads it to paint
+ * `visited` and to answer a click: one link may be drawn as SEVERAL anchors (a link whose
+ * text changes style mid-way is several runs), and the index is what ties them back
+ * together.
+ */
+export declare const LABEL_LINK_ATTRIBUTE = "data-gtk-link";
+/**
+ * `render` as nodes, ready to be put into a label.
+ *
+ * CONSECUTIVE RUNS OF ONE LINK SHARE ONE `<a>`, so a link is one navigable element to the
+ * keyboard and one entry in the accessibility tree even when its text changes style
+ * part-way through — which is what GTK's single link node is. Runs of DIFFERENT links, or
+ * a run with none between them, close the anchor.
+ */
+export declare function labelMarkupNodes(render: LabelMarkupRender, doc: Document, mnemonics?: boolean): Node[];
+/** Write `render` into `target`, replacing what was there. */
+export declare function renderLabelMarkup(target: HTMLElement, render: LabelMarkupRender, mnemonics?: boolean): void;
+/** The `<a>` elements {@link labelMarkupNodes} put under `target`, in reading order. */
+export declare function labelMarkupAnchors(target: HTMLElement): HTMLAnchorElement[];
+/**
+ * The link index `anchor` draws, or `null` when it is not one of ours.
+ *
+ * Read back from the attribute rather than closed over, because a click arrives at an
+ * element and the handler has only the DOM to go on.
+ */
+export declare function labelMarkupAnchorIndex(anchor: Element): number | null;

package/lib/types/namespace/gdk.d.ts

@@ -8,4 +8,4 @@ export declare const ContentProvider: Pick<typeof import("@gjsify/adwaita-core")
 export declare const ContentFormats: typeof import("@gjsify/adwaita-core").ContentFormats;
 export declare const AppLaunchContext: typeof import("@gjsify/adwaita-core").GdkAppLaunchContext;
 export declare const CURRENT_TIME = 0;
-export declare const KEY_space: 32, KEY_a: 97, KEY_d: 100, KEY_e: 101, KEY_q: 113, KEY_s: 115, KEY_w: 119, KEY_Return: 65293, KEY_Escape: 65307, KEY_Left: 65361, KEY_Up: 65362, KEY_Right: 65363, KEY_Down: 65364;
+export declare const KEY_space: 32, KEY_a: 97, KEY_d: 100, KEY_e: 101, KEY_q: 113, KEY_s: 115, KEY_w: 119, KEY_Return: 65293, KEY_Escape: 65307, KEY_Left: 65361, KEY_Up: 65362, KEY_Right: 65363, KEY_Down: 65364, KEY_Back: 269025062;

package/lib/types/pango-markup.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Pango tag → the HTML element that draws it, with the CSS it needs because no
+ * presentational UA rule covers it. Every entry is a CLOSED set: a tag missing here is a
+ * parse error, so there is no default branch to fall through.
+ */
+export declare const TAG_STYLES: Readonly<Record<string, {
+    element: string;
+    style?: Readonly<Record<string, string>>;
+}>>;
+/**
+ * Write the recognised `<span>` attributes onto `el` as style declarations.
+ *
+ * Exported for `label-markup.ts`, which draws a `Gtk.Label`'s markup from flat RUNS rather
+ * than from this file's tree: the whitelist and its value tables are the part the two must
+ * share, so an attribute is added once and both renderers gain it.
+ */
+export declare function applySpanAttributes(el: HTMLElement, attributes: Readonly<Record<string, string>>): void;
 /**
  * Render Pango markup into `target`, replacing its content — the one door every
  * `use-markup` surface in this package goes through.