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

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-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/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.