@gjsify/adwaita-web 0.54.0 → 0.56.0

package/lib/types/elements/gtk-drawing-area.d.ts

@@ -0,0 +1,95 @@
+/**
+ * `GtkDrawingAreaDrawFunc` with the `user_data` / `destroy` pair dropped — see the header.
+ *
+ * @param area the drawing area being painted, as the C's first argument
+ * @param cr a 2D context over the whole allocation, in logical pixels
+ * @param width the width of the allocation — NOT of `content-width`
+ * @param height the height of the allocation — NOT of `content-height`
+ */
+export type GtkDrawingAreaDrawFunc = (area: GtkDrawingArea, cr: CanvasRenderingContext2D, width: number, height: number) => void;
+export declare class GtkDrawingArea extends HTMLElement {
+    private _canvas;
+    private _context;
+    private _initialized;
+    private _drawFunc;
+    /** The last allocation the draw function was called with, as `::resize` sees it. */
+    private _width;
+    private _height;
+    /** The last device pixel ratio the backing store was built for. */
+    private _scale;
+    private _resize;
+    private _frame;
+    static get observedAttributes(): string[];
+    /** `Gtk.DrawingArea:content-width` — the minimum AND natural width. Defaults to 0. */
+    get contentWidth(): number;
+    set contentWidth(v: number);
+    /** `Gtk.DrawingArea:content-height` — the minimum AND natural height. Defaults to 0. */
+    get contentHeight(): number;
+    set contentHeight(v: number);
+    /**
+     * Every GObject setter here returns early when the value is already right
+     * (gtkdrawingarea.c:373, :423), while `setAttribute` runs the reaction for a write
+     * that changes nothing — so the guard that makes "notify only on a real change" true
+     * for the numeric half is the same one `<gtk-level-bar>` uses.
+     */
+    private _write;
+    /** `GtkDrawingAreaDrawFunc`, or `null` — GTK's default, which paints nothing (:251). */
+    get drawFunc(): GtkDrawingAreaDrawFunc | null;
+    set drawFunc(fn: GtkDrawingAreaDrawFunc | null);
+    /**
+     * `gtk_drawing_area_set_draw_func` (gtkdrawingarea.c:474-491): store the function and
+     * `queue_draw`, which is what repaints. Passing `null` clears it, and the next
+     * snapshot leaves the widget blank — the C's early return at :251.
+     */
+    setDrawFunc(fn: GtkDrawingAreaDrawFunc | null): void;
+    /**
+     * `gtk_widget_queue_draw` on this widget: the documented way to ask for the draw
+     * function to be called again (gtkdrawingarea.c:127-129).
+     *
+     * AND WHY IT IS NOT IMMEDIATE. `queue_draw` marks the window dirty and the frame clock
+     * draws it on the next frame, so a draw function that calls `queue_draw` keeps
+     * ANIMATING rather than recursing — and a 2D canvas drawn synchronously would turn the
+     * same application into a stack overflow. One animation frame is the browser's frame
+     * clock, and coalescing through it is what makes "paint from the function" a loop and
+     * not a crash. Several requests before the frame are one frame, as in the C.
+     */
+    queueDraw(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `measure` returns one number per axis as the minimum AND the natural size
+     * (gtkdrawingarea.c:210-231), and CSS has a property for each half — so the element
+     * publishes the number once and `_drawing.scss` reads it twice. A zero removes the
+     * property rather than declaring `0px`, because `var(--adw-drawing-width, auto)` is
+     * how "no intrinsic size" is spelled.
+     */
+    private _publishSize;
+    private _observe;
+    /**
+     * `gtk_drawing_area_size_allocate` (:233-238) emits `::resize` and does nothing else —
+     * the signal IS the allocation path. The browser learns the allocation from the
+     * observer instead, so the signal is emitted from here, and only when the allocation
+     * really changed: GTK reaches `size_allocate` on every layout pass, and the signal
+     * is documented as firing "each time the widget is changed" (:312-314).
+     */
+    private _allocated;
+    /**
+     * One frame. `gtk_drawing_area_snapshot` (:240-267) measures the ALLOCATION, not the
+     * properties, and calls the function with it; the browser gets the allocation from the
+     * observer instead of from the snapshot, and the drawing itself is the 2D context the
+     * canvas already owns.
+     */
+    private _draw;
+    /** The backing store is rebuilt when the display's ratio changes, not every frame. */
+    private _devicePixelRatio;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _notify;
+    /** The last allocation, as `::resize` reported it — the spec reads it back. */
+    get allocation(): {
+        width: number;
+        height: number;
+    };
+    /** The ratio the backing store was built at, as the header describes. */
+    get pixelScale(): number;
+}

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

@@ -0,0 +1,33 @@
+export declare class GtkEditableLabel extends HTMLElement {
+    private _label;
+    private _entry;
+    private _initialized;
+    private _grace;
+    static get observedAttributes(): string[];
+    /** `Gtk.Editable:text` — what the label shows, which is the committed draft. */
+    get text(): string;
+    set text(value: string);
+    /** `Gtk.Editable:editable` — defaults TRUE. FALSE refuses to start editing. */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /**
+     * `GtkEditableLabel:editing` — TRUE while the entry is the stack's visible child, so it
+     * is the ATTRIBUTE as on every other boolean here. Setting it is what starts or stops
+     * editing, because the C's property setter does exactly that (gtkeditablelabel.c:406-411).
+     */
+    get editing(): boolean;
+    set editing(value: boolean);
+    /** `gtk_editable_label_start_editing` — refused while `editable` is FALSE, as in the C. */
+    startEditing(): void;
+    /**
+     * `gtk_editable_label_stop_editing` — `commit` decides whether the drafted text becomes
+     * the label's; FALSE resets the entry to the label instead (gtkeditablelabel.c:637-656).
+     */
+    stopEditing(commit?: boolean): void;
+    /** The inner native entry, for focus and selection. */
+    get entry(): HTMLInputElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _render;
+}

package/lib/types/elements/gtk-emoji-chooser.d.ts

@@ -0,0 +1,84 @@
+import { type EmojiEntry } from '../emoji-data.js';
+import { GtkPopover } from './gtk-popover.js';
+export declare class GtkEmojiChooser extends GtkPopover {
+    private _built;
+    private _entry;
+    private _listEl;
+    private _emptyEl;
+    private _sections;
+    /** The entry a button was built from — `emoji-data` has no reverse lookup. */
+    private _entryOf;
+    /** `recently-used-emoji` — the GSettings key, held in memory here (see the header). */
+    private _recent;
+    /**
+     * The Ctrl state `should_close` reads off the keyboard (:433-448). A DOM event's
+     * `ctrlKey` says what the key that caused IT was, and a `click` synthesised from a
+     * keyboard activation carries no modifier at all, so the state is tracked from the key
+     * events themselves — which is what `gdk_device_get_modifier_state` answers.
+     */
+    private _ctrl;
+    connectedCallback(): void;
+    /** The emoji picked most recently, newest first — what `recently-used-emoji` holds. */
+    get recentEmoji(): EmojiEntry[];
+    /**
+     * Pick an entry the flow box's `child-activated` would have delivered — which is what
+     * a consumer inserting an emoji from elsewhere needs, and what a test drives the recents
+     * with. `fromRecent` is `emoji_activated`'s own half of the recent check: an entry
+     * picked out of the recent list is not recorded a second time.
+     */
+    pick(entry: EmojiEntry, fromRecent?: boolean): void;
+    /** The `.emoji-searchbar` box: the magnifying glyph and the search entry. */
+    private _buildSearchbar;
+    /** The `empty` stack page: the big glyph and the two lines under it. */
+    private _buildEmptyPage;
+    /** One flow box per category, each under its own heading label. */
+    private _buildSections;
+    /**
+     * The toolbar: one `.emoji-section` button per section, recent FIRST (the struct
+     * order), each with its own symbolic and the `.ui`'s tooltip.
+     *
+     * The icons are written out one call per section rather than looked up from a table:
+     * each name is USED there, which is what makes it a name this stylesheet has to be
+     * able to draw — `scripts/check-adwaita-icon-masks.mjs` reads exactly that.
+     */
+    private _buildToolbar;
+    /** `button.image-button.emoji-section` — flat, circular, 32px, with a tooltip. */
+    private _sectionButton;
+    /**
+     * One emoji: a `<button>` holding the glyph at `PANGO_SCALE_X_LARGE`, labelled with
+     * the English name — the name the search reads, so it is the accessible name too.
+     */
+    private _emojiButton;
+    /** `filter_func` + `match_tokens`: EVERY term must be a PREFIX of a token of the name
+     * or of one of the keywords. `g_str_tokenize_and_fold` case-folds, hence lower-casing
+     * both sides. */
+    private _matches;
+    /** `search_changed` — invalidate every section, then `update_headings`. */
+    private _filter;
+    /** `emoji_activated` — emit, remember, and pop down unless Ctrl is held. */
+    private _activate;
+    /** `add_recent_item` (:390) — newest first, no duplicates, at most `MAX_RECENT`. */
+    private _remember;
+    /** `populate_recent_section` (:366-388): the list, its visibility and its button. */
+    private _renderRecents;
+    /**
+     * `show_variations` (:508-548): the plain form and the five skin tones
+     * (`add_emoji (box, FALSE, emoji_data, 0, …)` then `1F3FB`…`1F3FF`), in a popover over
+     * the emoji — and only for an emoji that HAS them, which is `has_variations` (:489).
+     */
+    private _showVariations;
+    private _closeVariations;
+    /** `scroll_to_section` (:312-330) — to the heading, minus `BOX_SPACE`. */
+    private _scrollTo;
+    /** `gtk_emoji_chooser_scroll_section` (:1198) — Ctrl+N / Ctrl+P over the visible ones. */
+    private _scrollSection;
+    /** `activate_search` (:1019) — the first result of the first non-empty section. */
+    private _activateFirstResult;
+    /**
+     * `adj_value_changed` (:814-870): the section the scroll position is INSIDE is the
+     * checked one, so the toolbar follows the list without any interaction of its own.
+     */
+    private _sectionAt;
+    private _currentSection;
+    private _markSection;
+}

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

@@ -1,5 +1,11 @@
 export declare class GtkEntry extends HTMLElement {
-    private _input;
+    /**
+     * `protected`, not `private`: `GtkPasswordEntry` and `GtkSearchEntry` subclass this
+     * element and restyle or wrap the very input it builds (the password field's Caps Lock
+     * and peek listeners, the search field's leading icon and trailing clear button), so the
+     * inner node is theirs to reach as well as this class's.
+     */
+    protected _input: HTMLInputElement;
     private _initialized;
     private _maxLength;
     static get observedAttributes(): string[];
@@ -10,8 +16,21 @@ export declare class GtkEntry extends HTMLElement {
     set maxLength(value: number);
     /** `Gtk.Entry:text-length` — code points, not UTF-16 units. */
     get textLength(): number;
+    /**
+     * `Gtk.Entry:placeholder-text`, the name a Blueprint file and the gallery trees use.
+     * `placeholder` stays for markup written before the GTK spelling was read.
+     */
+    private placeholderAttribute;
+    /** `Gtk.Widget:width-request` — a minimum width in px; -1 or absent leaves the natural one. */
+    private applyWidthRequest;
     /** The inner native input (for focus/selection). */
     get input(): HTMLInputElement;
     connectedCallback(): void;
+    /**
+     * Declared so a subclass can override it and still reach the base: the custom-element
+     * lifecycle hooks a subclass chains (`super.disconnectedCallback()`) have to exist on
+     * the class it extends, and `GtkSearchEntry` drops its pending search timeout here.
+     */
+    disconnectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
 }

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

@@ -0,0 +1,49 @@
+import './gtk-label.js';
+export declare class GtkExpander extends HTMLElement {
+    private _box;
+    private _titleEl;
+    private _arrowEl;
+    private _labelEl;
+    private _labelSection;
+    private _contentEl;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Gtk.Expander:expanded` — whether the child is revealed. */
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    /** `Gtk.Expander:label` — the title TEXT, or `null` when a label widget is in its place. */
+    get label(): string | null;
+    set label(value: string | null);
+    /** `Gtk.Expander:use-markup` — whether the label is Pango markup. */
+    get useMarkup(): boolean;
+    set useMarkup(value: boolean);
+    /** `Gtk.Expander:use-underline` — whether `_` in the label marks a mnemonic. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** `Gtk.Expander:resize-toplevel` — reflected, because a document reflows itself. */
+    get resizeToplevel(): boolean;
+    set resizeToplevel(value: boolean);
+    /** `Gtk.Expander:child` — the light-DOM node in the content row. */
+    get child(): Element | null;
+    /** `Gtk.Expander:label-widget` — the light-DOM node standing in for the label text. */
+    get labelWidget(): Element | null;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _detail;
+    /** `gtk_expander_activate` (gtkexpander.c:786-792) — the one thing the widget does. */
+    private _activate;
+    /**
+     * `Alt`+the marked character, as `gtk_expander_new_with_mnemonic` documents
+     * (gtkexpander.c:856-860): "Pressing Alt and that key activates the button."
+     */
+    private readonly _onKeyDown;
+    /**
+     * The single character `use-underline` marks, or `null` when none does.
+     *
+     * The walk is `stripMnemonic`'s, for the reason that function gives: a `_` takes the
+     * character after it and is itself removed, `__` is an escaped literal underscore and
+     * marks nothing, and a trailing marker has no character to take.
+     */
+    private _mnemonic;
+    private _render;
+}

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

@@ -0,0 +1,13 @@
+export declare class GtkFixed extends HTMLElement {
+    private _resize;
+    private _mutations;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** `gtk_fixed_put()` — a child and the position it sits at, both relative to the fixed. */
+    put(child: HTMLElement, x: number, y: number): void;
+    /** `gtk_fixed_move()` — the same position for a child already in this fixed. */
+    move(child: HTMLElement, x: number, y: number): void;
+    private _observeChildren;
+    /** `gtk_fixed_layout_measure`: the union of the children's rectangles, as one box. */
+    private _size;
+}

package/lib/types/elements/gtk-flow-box-child.d.ts

@@ -0,0 +1,14 @@
+export declare class GtkFlowBoxChild extends HTMLElement {
+    private _contentsEl;
+    private _initialized;
+    connectedCallback(): void;
+    /** `GtkFlowBoxChild:child`, as the light-DOM child it already is. */
+    get child(): Element | null;
+    /** Where this child sits in its box, or -1 while it has no box. */
+    get index(): number;
+    /**
+     * `gtk_flow_box_child_is_selected` — read over the class the box writes, so a cell moved
+     * between boxes never carries a stale answer.
+     */
+    get selected(): boolean;
+}

package/lib/types/elements/gtk-flow-box.d.ts

@@ -0,0 +1,87 @@
+import { type AdwBoxSelectionMode } from '@gjsify/adwaita-core';
+import type { GtkFlowBoxChild } from './gtk-flow-box-child.js';
+import './gtk-flow-box-child.js';
+/** `GtkFlowBox:max-children-per-line`'s default — `DEFAULT_MAX_CHILDREN_PER_LINE` (:728). */
+export declare const ADW_FLOW_BOX_MAX_CHILDREN_PER_LINE = 7;
+/** `GtkFlowBox:orientation` — HORIZONTAL by default here, unlike a `GtkListBase` (:3981). */
+export type AdwFlowBoxOrientation = 'horizontal' | 'vertical';
+export declare class GtkFlowBox extends HTMLElement {
+    private _children;
+    private _selection;
+    /** `priv->selected_child`, `-1` for the C's NULL. */
+    private _anchor;
+    private _initialized;
+    static get observedAttributes(): string[];
+    get selectionMode(): AdwBoxSelectionMode;
+    set selectionMode(value: AdwBoxSelectionMode);
+    /** Default TRUE (gtkflowbox.c:3723), so the attribute is the OFF switch. */
+    get activateOnSingleClick(): boolean;
+    set activateOnSingleClick(value: boolean);
+    /** Default FALSE (gtkflowbox.c:3731). Read as boolean because a browser always pairs a
+     * click's halves somewhere; see `<gtk-list-box>`'s header for the rest. */
+    get acceptUnpairedRelease(): boolean;
+    set acceptUnpairedRelease(value: boolean);
+    get homogeneous(): boolean;
+    set homogeneous(value: boolean);
+    /** `GtkFlowBox:min-children-per-line` — 0 is the ParamSpec default (:3758). */
+    get minChildrenPerLine(): number;
+    set minChildrenPerLine(value: number);
+    /** `GtkFlowBox:max-children-per-line` — 7 is the default, and the ParamSpec's MINIMUM is 1. */
+    get maxChildrenPerLine(): number;
+    set maxChildrenPerLine(value: number);
+    get rowSpacing(): number;
+    set rowSpacing(value: number);
+    get columnSpacing(): number;
+    set columnSpacing(value: number);
+    get orientation(): AdwFlowBoxOrientation;
+    set orientation(value: AdwFlowBoxOrientation);
+    /**
+     * The cells, in document order — GTK's `children` sequence.
+     *
+     * NOT spelled `children`: that name is `HTMLElement.children`, an `HTMLCollection`, and
+     * shadowing it on an element that HAS children would break `firstElementChild` consumers
+     * and the DOM's own `[...el.children]` idiom everywhere else in this package.
+     */
+    get cells(): readonly GtkFlowBoxChild[];
+    /** The selected positions, ascending. A method upstream (`get_selected_children`). */
+    get selectedChildren(): number[];
+    set selectedChildren(value: Iterable<number> | number | null);
+    get selectedChildElements(): GtkFlowBoxChild[];
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    /** `gtk_flow_box_select_child` (gtkflowbox.c:4731-4739). `null` is the C's unselect-all. */
+    selectChild(child: GtkFlowBoxChild | null): void;
+    /** `gtk_flow_box_unselect_child` (gtkflowbox.c:4749-4756). */
+    unselectChild(child: GtkFlowBoxChild): void;
+    /** `gtk_flow_box_select_all` — refused unless the mode is `multiple` (:4770-4771). */
+    selectAll(): void;
+    /** `gtk_flow_box_unselect_all` — refused in `browse` (:4792-4793). */
+    unselectAll(): void;
+    /**
+     * The properties, as inline custom properties, so the flex rules in `_flow_box.scss` stay
+     * declarative and a `homogeneous` write is one class flip.
+     */
+    private _applyAttributes;
+    private _collectChildren;
+    /**
+     * The `GTK_STATE_FLAG_SELECTED` each selected cell raises and the accessible state that
+     * goes with it (`gtk_flow_box_child_set_selected`, gtkflowbox.c:943-962). The accessible
+     * state is published ONLY while the box can select, which is the same reset the list box
+     * does (:3617-3623).
+     */
+    private _syncChildren;
+    private _onClick;
+    private _onDoubleClick;
+    /**
+     * `Ctrl`+Space is `toggle-cursor-child` (gtkflowbox.c:3957-3959); Enter and Space are the
+     * CELL's, via `activate-cursor-child` (:3836) and `GtkFlowBoxChild`'s own `activate`.
+     */
+    private _onKeyDown;
+    private _childAt;
+    /** One click or `Ctrl`+Space — `gtk_flow_box_update_selection` (:1077-1131). */
+    private _updateSelection;
+    /** `gtk_flow_box_select_and_activate` (:1136-1148) — the `child-activated` signal. */
+    private _activate;
+    /** `child-activated`'s companion `selected-children-changed` (:3820-3826) plus the notify. */
+    private _emitSelection;
+}

package/lib/types/elements/gtk-font-dialog-button.d.ts

@@ -0,0 +1,83 @@
+import { type PangoFontDescription } from '../font-description.js';
+import './gtk-popover.js';
+import './gtk-separator.js';
+/** `GtkFontLevel`'s four values, under the nicks a string property carries. */
+export type FontLevel = 'family' | 'face' | 'font' | 'features';
+/** `GtkFontDialog`'s own parameters; `font-map` has no browser counterpart and is absent. */
+export interface FontDialogParameters {
+    /** Whether the chooser is modal. Default `TRUE`, as in the GIR. */
+    modal?: boolean;
+    /** The chooser's title. Default `null`. */
+    title?: string | null;
+    /** The language font features are resolved against. Default `null`. */
+    language?: string | null;
+    /** Whether only scalable fonts are offered. */
+    filter?: number;
+}
+export declare class GtkFontDialogButton extends HTMLElement {
+    private _buttonEl;
+    private _labelEl;
+    private _sizeBoxEl;
+    private _sizeLabelEl;
+    private _dockEl;
+    private _selectEl;
+    private _desc;
+    private _dialog;
+    private _features;
+    private _language;
+    private _pending;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `GtkFontDialogButton:font-desc` — the selected font, as a plain value. */
+    get fontDesc(): PangoFontDescription;
+    set fontDesc(value: PangoFontDescription | string);
+    /** `GtkFontDialogButton:font-features` — Pango's comma-separated feature list. */
+    get fontFeatures(): string;
+    set fontFeatures(value: string);
+    /** `GtkFontDialogButton:language` — the language font features resolve against. */
+    get language(): string | null;
+    set language(value: string | null);
+    /** `GtkFontDialogButton:level` — how much of the font the chooser offers. */
+    get level(): FontLevel;
+    set level(value: FontLevel);
+    /** `GtkFontDialogButton:use-font` — draw the family label in the selected font. */
+    get useFont(): boolean;
+    set useFont(value: boolean);
+    /** `GtkFontDialogButton:use-size` — draw the selected SIZE in the label too. */
+    get useSize(): boolean;
+    set useSize(value: boolean);
+    /** `GtkFontDialogButton:dialog` — the chooser this button opens, or `null` for none. */
+    get dialog(): FontDialogParameters | null;
+    set dialog(value: FontDialogParameters | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * The `::activate` action signal (:405-418), bound to `gtk_widget_activate (self->button)`
+     * (:540-546): activating the widget and pressing the button are the same thing, and
+     * both present the chooser.
+     */
+    activate(): void;
+    /** `button_clicked` (:548-585), with the level deciding which C handler would answer. */
+    private _openChooser;
+    /**
+     * The combinations this page can actually render, plus the one already held.
+     *
+     * `FontFaceSet.check()` is the browser's font map in one call, and it is a QUESTION
+     * ABOUT A DESCRIPTION, which is exactly the shape of Pango's face walk: the family is
+     * the outer loop, the face the inner one, and a combination that does not render is
+     * the face the family does not have.
+     */
+    private _options;
+    /** The four `*_chosen` handlers (:441-538), by level. */
+    private _choose;
+    /** `update_button_sensitivity` (:433-439), as the colour button's is (:380-391). */
+    private _renderSensitivity;
+    /** `update_font_info` (:649-687) plus `apply_use_font` (:689-720). */
+    private _render;
+    /**
+     * `font_description_style_equal` against the faces the page declares — the stand-in for
+     * the font-map walk `update_font_data` performs, and the name it prints when there is
+     * one.
+     */
+    private _faceName;
+}

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

@@ -0,0 +1,24 @@
+export declare class GtkFrame extends HTMLElement {
+    private _mutations;
+    static get observedAttributes(): string[];
+    /** The element's own `<gtk-label>`, built from `label` — null while no string is set. */
+    private _labelEl;
+    /** True while {@link _sync} writes `label` onto that widget, so its notify does not escape. */
+    private _writingLabel;
+    /** `Gtk.Frame:label` — the frame's label text, or null when it carries no label. */
+    get label(): string | null;
+    set label(value: string | null);
+    /**
+     * `Gtk.Frame:label-xalign` — where the label sits across the frame's width.
+     * `0` (the pspec default) puts it at the start, `1` at the end, `0.5` centred.
+     */
+    get labelXalign(): number;
+    set labelXalign(value: number);
+    /** The child in GTK's `label-widget` slot — the widget drawn in place of the text. */
+    get labelWidget(): HTMLElement | null;
+    set labelWidget(value: HTMLElement | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _sync;
+}

package/lib/types/elements/gtk-gl-area.d.ts

@@ -0,0 +1,136 @@
+/** `GdkGLAPI`'s nicks, as `GdkGLAPINickSet` spells them. */
+declare const APIS: readonly ["gl", "gles"];
+type GlApi = (typeof APIS)[number];
+/** A WebGL context, whichever version the browser handed out. */
+type GlContext = WebGLRenderingContext | WebGL2RenderingContext;
+export declare class GtkGLArea extends HTMLElement {
+    private _canvas;
+    private _messageEl;
+    private _initialized;
+    private _context;
+    private _error;
+    /** `gtk_gl_area_resize` is called from here, so `needs_resize` is a C field too. */
+    private _needsResize;
+    /** `priv->needs_render`, TRUE from `gtk_gl_area_init` (:1104). */
+    /** `priv->allowed_apis`, default `GDK_GL_API_GL | GDK_GL_API_GLES` (:1100). */
+    private _allowedApis;
+    private _needsRender;
+    /** `priv->have_buffers` (:392), dropped by the two buffer setters. */
+    private _haveBuffers;
+    private _width;
+    private _height;
+    private _scale;
+    private _resize;
+    private _frame;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkGLArea:auto-render` — whether `::render` is emitted every time the widget draws.
+     * Defaults to TRUE (:1102, and `g_param_spec_boolean` at :924).
+     */
+    get autoRender(): boolean;
+    set autoRender(v: boolean);
+    /**
+     * `GtkGLArea:has-depth-buffer` — whether a depth buffer is allocated and the depth
+     * test enabled (:782-785, :408-417). Defaults to FALSE (:941).
+     */
+    get hasDepthBuffer(): boolean;
+    set hasDepthBuffer(v: boolean);
+    /** `GtkGLArea:has-stencil-buffer` — the stencil half of the same renderbuffer (:954). */
+    get hasStencilBuffer(): boolean;
+    set hasStencilBuffer(v: boolean);
+    /**
+     * `GtkGLArea:allowed-apis` — the APIs a created context may use (:983, :1100).
+     *
+     * The value lives in a field, not in the attribute, because the setter REFUSES a
+     * realized area and a refused write in a custom element has already moved the
+     * attribute — the C keeps the property and drops the call, this keeps the property and
+     * puts the attribute back.
+     */
+    get allowedApis(): GlApi[];
+    set allowedApis(v: GlApi[]);
+    /**
+     * The guard that makes "notify only on a real change" true: `setAttribute` runs the
+     * custom-element reaction for a write that changes nothing, while GTK's setters
+     * return early (:1522, :1197).
+     */
+    private _write;
+    /**
+     * `GtkGLArea:api` — the API in use, read-only in the GIR and defaulting to 0, which
+     * is `GDK_GL_API_GL`. A context in a browser is WebGL or WebGL2, both ES, so a
+     * realized area reports `gles` and an unrealized one the pspec's `0` — see the header.
+     */
+    get api(): GlApi;
+    /** `gtk_gl_area_get_context` (:1495-1508) — the context, or `null` when there is none. */
+    get context(): GlContext | null;
+    /** `gtk_gl_area_get_error` (:1533-1543) — the error set on the area, if any. */
+    get error(): string | null;
+    /** `gtk_gl_area_set_error` (:1545-1558). `null` clears it, which restores drawing. */
+    setError(error: Error | string | null): void;
+    /**
+     * `gtk_gl_area_make_current` (:1563-1572). A WebGL context is current for its own
+     * canvas and nowhere else, so there is nothing to switch — the method exists
+     * because the C's callers expect it to.
+     */
+    makeCurrent(): GlContext | null;
+    /**
+     * `gtk_gl_area_queue_render` (:1465-1474) — the render flag plus `queue_draw`.
+     *
+     * AND WHY THE DRAW IS NOT SYNCHRONOUS. `gtk_widget_queue_draw` marks the window dirty
+     * and the frame clock draws it LATER, so an application that queues per tick animates
+     * instead of recursing; a 2D-style synchronous draw would make the same application a
+     * stack overflow. An animation frame is the browser's frame clock, and coalescing
+     * through one keeps "ask for a frame" a scheduler.
+     *
+     * NOTE WHAT THE FLAG DOES NOT SURVIVE: `needs_render` is cleared AFTER the `::render`
+     * emit (:811), so a `queue_render()` from inside the handler has its flag overwritten
+     * and only the queued frame remains. That is the C's own behaviour, and it is why an
+     * animation asks from a tick callback rather than from the handler.
+     */
+    queueRender(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** `gtk_widget_queue_draw`: one frame, however many requests arrived before it. */
+    private _queueDraw;
+    attributeChangedCallback(name: string): void;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _notify;
+    private _observe;
+    /**
+     * The snapshot, in the C's order (gtkglarea.c:757-812). One pass, four early exits,
+     * and the two flags cleared only after the signals — see the header.
+     */
+    private _draw;
+    /**
+     * `gtk_gl_area_attach_buffers` (:583-618): the depth/stencil renderbuffer is created
+     * when either buffer is asked for and deleted when neither is — and `have_buffers`
+     * says which, so a redraw after one of the two setters is the frame that allocates
+     * it (:408-417). WebGL's equivalent is the depth and stencil TESTS plus the
+     * `depth`/`stencil` context attributes the element created the context with: a context
+     * cannot gain a buffer afterwards, which is why `_createContext` reads both properties
+     * before asking, and why the flag is what decides the tests are re-applied.
+     */
+    attachBuffers(context?: GlContext | null): void;
+    /**
+     * `::create-context` (:1086-1109) lets a handler supply the context, and GTK's handler
+     * RETURNS one. A browser event has no return channel, so the detail object is the
+     * channel: a handler that sets `detail.context` wins, and the element asks the
+     * browser only when nobody did.
+     */
+    private _createContext;
+    /**
+     * `gtk_gl_area_draw_error_screen` (:701-723): the message over the whole widget, at
+     * its own font, vertically centred. The canvas stays where it is — GTK's error screen
+     * replaces what a frame would have drawn, not the widget's own node — and the message
+     * node is removed again when the error clears, which is the redraw the C's setter
+     * queues (:1552-1556).
+     */
+    private _renderMessage;
+    /** The device-pixel viewport, for a spec that checks `::resize`. */
+    get viewport(): {
+        width: number;
+        height: number;
+    };
+    /** The scale factor the viewport is multiplied by (gtkglarea.c:761-763). */
+    get pixelScale(): number;
+}
+export {};