@gjsify/adwaita-web 0.64.1 → 0.64.2-next.254

package/src/test.browser.mts

@@ -28,6 +28,7 @@ import { AdwMultiLayoutViewTest } from './adw-multi-layout-view.spec.js';
 import { AdwDataGridTest } from './adw-data-grid.spec.js';
 import { GtkSourceViewTest } from './gtksource/gtk-source-view.spec.js';
 import { AdwDialogTest } from './adw-dialog.spec.js';
+import { WidgetMapTest } from './widget-map.spec.js';
 import { AdwWindowTest } from './adw-window.spec.js';
 import { AdwShortcutsTest } from './adw-shortcuts.spec.js';
 import { AdwApplicationWindowTest } from './adw-application-window.spec.js';
@@ -65,7 +66,7 @@ import { PangoMarkupTest } from './pango-markup.spec.js';
 import { CopyGlyphTest } from './source-view/copy-glyph.spec.js';
 import { AdwButtonContentTest } from './adw-button-content.spec.js';
 import { GtkImageTest } from './gtk-image.spec.js';
-import { AdwIconRegistryTest } from './icon-registry.spec.js';
+import { AdwIconMasksTest } from './icon-masks.spec.js';
 import { AdwIconThemeTest } from './icon-theme.spec.js';
 import { GioResourceTest } from './gio-resource.spec.js';
 import { GtkSwitchTest } from './gtk-switch.spec.js';
@@ -83,6 +84,7 @@ import { GtkListViewTest } from './gtk-list-view.spec.js';
 import { GtkHeaderBarTest } from './gtk-header-bar.spec.js';
 import { GtkWindowControlsTest } from './gtk-window-controls.spec.js';
 import { GtkWindowTest } from './gtk-window.spec.js';
+import { WindowMaximizeTest } from './window-maximize.spec.js';
 import { GtkApplicationWindowTest } from './gtk-application-window.spec.js';
 import { GtkActionBarTest } from './gtk-action-bar.spec.js';
 import { GtkSeparatorTest } from './gtk-separator.spec.js';
@@ -93,6 +95,8 @@ import { GtkTreeExpanderTest } from './gtk-tree-expander.spec.js';
 import { GtkToggleButtonTest } from './gtk-toggle-button.spec.js';
 import { GtkExpanderTest } from './gtk-expander.spec.js';
 import { GtkOverlayTest } from './gtk-overlay.spec.js';
+import { ContainerFillTest } from './container-fill.spec.js';
+import { ComputeExpandTest } from './compute-expand.spec.js';
 import { GtkPanedTest } from './gtk-paned.spec.js';
 import { GtkRevealerTest } from './gtk-revealer.spec.js';
 import { GtkScaleTest } from './gtk-scale.spec.js';
@@ -161,6 +165,9 @@ import { AdwValueListsTest } from './value-lists.spec.js';
 import { AdwBlueprintLayoutTest } from './blueprint-layout.spec.js';
 import { AdwWidgetSizeTest } from './widget-size.spec.js';
 import { AdwSharedTreeMountTest } from './shared-tree-mount.spec.js';
+import { AdwWidgetVisibleTest } from './widget-visible.spec.js';
+import { AdwChildSlotTest } from './child-slot.spec.js';
+import { AdwLearn6502WindowTest } from './learn6502-window.spec.js';
 import { AdwBlueprintMarkupTest } from './blueprint-markup.spec.js';
 import { AdwTagsTest } from './tags.spec.js';
 import { AdwFontStackTest } from './font-stack.spec.js';
@@ -183,6 +190,9 @@ run({
     AdwBlueprintLayoutTest,
     AdwWidgetSizeTest,
     AdwSharedTreeMountTest,
+    AdwWidgetVisibleTest,
+    AdwChildSlotTest,
+    AdwLearn6502WindowTest,
     AdwBlueprintMarkupTest,
     AdwTagsTest,
     AdwKeyboardOperableTest,
@@ -201,7 +211,7 @@ run({
     CopyGlyphTest,
     AdwButtonContentTest,
     GtkImageTest,
-    AdwIconRegistryTest,
+    AdwIconMasksTest,
     AdwIconThemeTest,
     GioResourceTest,
     GtkSwitchTest,
@@ -219,6 +229,7 @@ run({
     GtkHeaderBarTest,
     GtkWindowControlsTest,
     GtkWindowTest,
+    WindowMaximizeTest,
     GtkApplicationWindowTest,
     GtkActionBarTest,
     GtkSeparatorTest,
@@ -234,6 +245,8 @@ run({
     GtkToggleButtonTest,
     GtkExpanderTest,
     GtkOverlayTest,
+    ContainerFillTest,
+    ComputeExpandTest,
     GtkPanedTest,
     GtkRevealerTest,
     GtkScaleTest,
@@ -287,6 +300,7 @@ run({
     AdwDataGridTest,
     GtkSourceViewTest,
     AdwDialogTest,
+    WidgetMapTest,
     AdwWindowTest,
     AdwShortcutsTest,
     AdwApplicationWindowTest,

package/src/value-lists.spec.ts

@@ -63,9 +63,9 @@ export const AdwValueListsTest = async () => {
                         const dialog = root as unknown as AdwAlertDialog;
                         const read = vector.responses.map(({ id }) => ({
                             id,
-                            label: dialog.getResponseLabel(id),
-                            appearance: dialog.getResponseAppearance(id),
-                            enabled: dialog.getResponseEnabled(id),
+                            label: dialog.get_response_label(id),
+                            appearance: dialog.get_response_appearance(id),
+                            enabled: dialog.get_response_enabled(id),
                         }));
                         expect(JSON.stringify(read)).toBe(JSON.stringify(vector.responses));
                         // The buttons the dialog paints, in the order the source wrote them.

package/src/widget-element.ts

@@ -0,0 +1,75 @@
+// `Gtk.Widget`'s `visible` and `tooltip-text` on the element classes, once, so the types of every
+// widget carry them and so does a plain `document.createElement()`, not only a built tree.
+//
+// `WidgetElement` is `HTMLElement` plus `gtk_widget_get_visible` / `gtk_widget_set_visible` over
+// the DOM's `hidden` attribute, TRUE until hidden as GtkWidget's default is, and the `map` /
+// `unmap` signals with `gtk_widget_get_mapped` (`widget-mapping.ts`); `installVisible`
+// (`gobject-elements.ts`) gives the same to a class that does not extend it. It notifies only
+// where the element declares `notify::visible`. A subclass with its own `visible`
+// (`<gtk-stack-page>`, `<adw-sidebar>`) keeps its own.
+//
+// `TooltipElement` adds `Gtk.Widget:tooltip-text` for the elements that render the
+// `tooltip-text` attribute: a button, and the rows (`row-tooltip.ts`). It reflects that attribute
+// and the element's `attributeChangedCallback` draws it, so a widget that does not draw it does
+// not extend this class.
+//
+// Reference: GTK gtk/gtkwidget.c (gtk_widget_set_visible, gtk_widget_set_tooltip_text)
+// Copyright (c) GNOME contributors (GTK). LGPLv2.1+.
+
+import { WIDGET_VISIBLE_GETTERS, notifyElement } from './gobject-elements.js';
+import { dispatchedSignalsOf, type DispatchedSignals } from './signals.js';
+import { isMapped } from './widget-mapping.js';
+
+export class WidgetElement extends HTMLElement {
+    /** `Gtk.Widget::map` / `::unmap`, which every subclass inherits (`dispatchedSignalsOf`). */
+    static readonly signals: DispatchedSignals = { map: 'map', unmap: 'unmap' };
+
+    /** `Gtk.Widget:visible`. */
+    get visible(): boolean {
+        return !this.hidden;
+    }
+    set visible(value: boolean) {
+        const before = !this.hidden;
+        this.toggleAttribute('hidden', !value);
+        if (!this.hidden !== before && 'notify::visible' in dispatchedSignalsOf(this)) notifyElement(this, 'visible');
+    }
+    /** `gtk_widget_get_visible`. */
+    get_visible(): boolean {
+        return this.visible;
+    }
+    /** `gtk_widget_set_visible`. */
+    set_visible(visible: boolean): void {
+        this.visible = visible;
+    }
+    /** `gtk_widget_get_mapped`: on screen, which is in the document and rendered. */
+    get_mapped(): boolean {
+        return isMapped(this);
+    }
+}
+
+WIDGET_VISIBLE_GETTERS.add(Object.getOwnPropertyDescriptor(WidgetElement.prototype, 'visible')!.get!);
+
+export class TooltipElement extends WidgetElement {
+    /** `Gtk.Widget:tooltip-text`, the `tooltip-text` attribute; `null` while unset. */
+    get tooltip_text(): string | null {
+        return this.getAttribute('tooltip-text');
+    }
+    set tooltip_text(value: string | null) {
+        if (value === null || value === undefined) this.removeAttribute('tooltip-text');
+        else this.setAttribute('tooltip-text', value);
+    }
+    get tooltipText(): string | null {
+        return this.tooltip_text;
+    }
+    set tooltipText(value: string | null) {
+        this.tooltip_text = value;
+    }
+    /** `gtk_widget_get_tooltip_text`. */
+    get_tooltip_text(): string | null {
+        return this.tooltip_text;
+    }
+    /** `gtk_widget_set_tooltip_text`. */
+    set_tooltip_text(text: string | null): void {
+        this.tooltip_text = text;
+    }
+}

package/src/widget-map.spec.ts

@@ -0,0 +1,116 @@
+// `Gtk.Widget::map` / `::unmap` and `get_mapped()` on an element: WIDGET_MAP_VECTORS, plus the
+// program that found the gap — a registered `Adw.PreferencesDialog` subclass connecting `map` in
+// its constructor (Learn6502's preferences dialog), which threw "declares no signal 'map'".
+import { describe, expect, it } from '@gjsify/unit';
+import { driveWidgetMapVectors, WIDGET_MAP_VECTORS, type WidgetMapSubject } from '@gjsify/adwaita-core/conformance';
+
+import { Adw, GObject } from './index.js';
+import { installElementApi } from './gobject-elements.js';
+import type { WidgetElement } from './widget-element.js';
+
+type Connectable = HTMLElement & { connect(signal: string, handler: (...args: unknown[]) => unknown): number };
+
+function settle(): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+
+const hosts: HTMLElement[] = [];
+
+const subject: WidgetMapSubject = {
+    name: 'adwaita-web',
+    isOracle: false,
+    box() {
+        const el = document.createElement('gtk-box');
+        installElementApi(el);
+        return el;
+    },
+    append: (parent, child) => void (parent as HTMLElement).append(child as HTMLElement),
+    remove: (_parent, child) => void (child as HTMLElement).remove(),
+    present(widget) {
+        const host = document.createElement('div');
+        host.append(widget as HTMLElement);
+        document.body.append(host);
+        hosts.push(host);
+    },
+    setVisible: (widget, visible) => void ((widget as WidgetElement).visible = visible),
+    connect: (widget, signal, handler) => (widget as Connectable).connect(signal, handler),
+    isMapped: (widget) => (widget as WidgetElement).get_mapped(),
+    settle,
+    dispose() {
+        for (const host of hosts.splice(0)) host.remove();
+    },
+};
+
+class GoWebMapDialog extends Adw.PreferencesDialog {
+    log: string[] = [];
+    constructor(params?: Record<string, unknown>) {
+        // @ts-expect-error the element's own constructor takes none; the registered class's takes the params
+        super(params);
+        const self = this as unknown as Connectable & { get_mapped(): boolean };
+        self.connect('map', () => this.log.push(`map:${self.get_mapped()}`));
+        self.connect('unmap', () => this.log.push(`unmap:${self.get_mapped()}`));
+    }
+}
+GObject.registerClass({ GTypeName: 'GoWebMapDialog' }, GoWebMapDialog);
+
+export const WidgetMapTest = async () => {
+    await driveWidgetMapVectors(subject, { describe, it, expect }, WIDGET_MAP_VECTORS);
+
+    await describe('adwaita-web: map / unmap on an element', async () => {
+        await it('every widget declares both, a subclass with its own signals too', () => {
+            for (const tag of ['gtk-box', 'gtk-button', 'adw-preferences-dialog']) {
+                const el = document.createElement(tag);
+                installElementApi(el);
+                expect(() => (el as Connectable).connect('map', () => {})).not.toThrow();
+                expect(() => (el as Connectable).connect('unmap', () => {})).not.toThrow();
+            }
+            // `<gtk-button>` declares `clicked` itself and still has `map`.
+            const button = document.createElement('gtk-button');
+            installElementApi(button);
+            expect(() => (button as Connectable).connect('clicked', () => {})).not.toThrow();
+        });
+
+        await it('a registered dialog connecting `map` in its constructor maps on present() and unmaps on close()', async () => {
+            const dialog = new (GoWebMapDialog as unknown as new () => GoWebMapDialog)();
+            await settle();
+            expect(dialog.log).toStrictEqual([]);
+            (dialog as unknown as { present(): void }).present();
+            await settle();
+            expect(dialog.log).toStrictEqual(['map:true']);
+            (dialog as unknown as { close(): void }).close();
+            await settle();
+            expect(dialog.log).toStrictEqual(['map:true', 'unmap:false']);
+            dialog.remove();
+        });
+
+        await it('a disconnected handler stops the watch: no emission after it', async () => {
+            const box = subject.box() as Connectable & { disconnect(id: number): void };
+            let emitted = 0;
+            const id = box.connect('map', () => void emitted++);
+            box.disconnect(id);
+            subject.present(box);
+            await settle();
+            expect(emitted).toBe(0);
+            subject.dispose();
+        });
+
+        await it('a popover that opens maps, one that closes unmaps', async () => {
+            const host = document.createElement('div');
+            const popover = document.createElement('div');
+            popover.setAttribute('popover', '');
+            const inner = subject.box() as Connectable;
+            popover.append(inner);
+            host.append(popover);
+            document.body.append(host);
+            const log: string[] = [];
+            inner.connect('map', () => void log.push('map'));
+            inner.connect('unmap', () => void log.push('unmap'));
+            popover.showPopover();
+            await settle();
+            popover.hidePopover();
+            await settle();
+            host.remove();
+            expect(log).toStrictEqual(['map', 'unmap']);
+        });
+    });
+};

package/src/widget-mapping.ts

@@ -0,0 +1,100 @@
+// `Gtk.Widget`'s `map` / `unmap` signals and `gtk_widget_get_mapped` on an element.
+//
+// A widget is mapped while it is on screen: it is visible and so is every ancestor. Here that is
+// an element in the document that renders (`isConnected && checkVisibility()`), which covers a
+// `hidden` ancestor, a closed `<dialog>`, an inactive stack page and a popover that is not open.
+// `map` fires on the transition into that state and `unmap` on the way out, never on connect.
+//
+// The DOM has no event for either transition, so an element is only WATCHED while something
+// listens to one of the two: one `MutationObserver` on the document (children and attributes,
+// the whole subtree) and a capturing `toggle` listener (a popover opening changes no attribute)
+// re-check every watched element after each batch. A batch is delivered after the change, not
+// inside it as `gtk_widget_show` delivers it; a hide undone within the same turn emits nothing.
+//
+// Order is GTK's post-order (`map` and `unmap` are RUN_FIRST, and the class handler maps or
+// unmaps the children first): the deepest element of a batch emits first, unmaps before maps.
+//
+// Reference: GTK gtk/gtkwidget.c (gtk_widget_map, gtk_widget_unmap, gtk_widget_real_map,
+// gtk_widget_real_unmap, gtk_widget_get_mapped)
+// Copyright (c) GNOME contributors (GTK). LGPLv2.1+.
+
+/** Watched elements and the state each last emitted for. */
+const STATE = new WeakMap<HTMLElement, { mapped: boolean; listeners: number }>();
+const WATCHED = new Set<WeakRef<HTMLElement>>();
+const REFS = new WeakMap<HTMLElement, WeakRef<HTMLElement>>();
+let observer: MutationObserver | null = null;
+
+/** `gtk_widget_get_mapped`: in the document, and rendered. */
+export function isMapped(el: Element): boolean {
+    return el.isConnected && el.checkVisibility();
+}
+
+function depthOf(el: Element): number {
+    let depth = 0;
+    for (let at = el.parentElement; at !== null; at = at.parentElement) depth++;
+    return depth;
+}
+
+function recheck(): void {
+    const changed: HTMLElement[] = [];
+    for (const ref of WATCHED) {
+        const el = ref.deref();
+        if (el === undefined) {
+            WATCHED.delete(ref);
+            continue;
+        }
+        const state = STATE.get(el)!;
+        if (isMapped(el) !== state.mapped) changed.push(el);
+    }
+    if (changed.length === 0) return;
+    const deepestFirst = (list: HTMLElement[]) =>
+        list.map((el) => [el, depthOf(el)] as const).sort((a, b) => b[1] - a[1]);
+    const unmapped = deepestFirst(changed.filter((el) => STATE.get(el)!.mapped));
+    const mapped = deepestFirst(changed.filter((el) => !STATE.get(el)!.mapped));
+    for (const [el] of [...unmapped, ...mapped]) {
+        const state = STATE.get(el)!;
+        state.mapped = !state.mapped;
+        el.dispatchEvent(new CustomEvent(state.mapped ? 'map' : 'unmap'));
+    }
+}
+
+function observe(): void {
+    if (observer !== null) return;
+    observer = new MutationObserver(recheck);
+    observer.observe(document, { childList: true, subtree: true, attributes: true });
+    document.addEventListener('toggle', recheck, true);
+}
+
+function unobserve(): void {
+    if (observer === null || WATCHED.size > 0) return;
+    observer.disconnect();
+    observer = null;
+    document.removeEventListener('toggle', recheck, true);
+}
+
+/**
+ * Watches `el` for `map` / `unmap` while the returned function has not been called. Its present
+ * state is recorded and not emitted, as connecting a handler in GTK emits nothing.
+ */
+export function watchMapping(el: HTMLElement): () => void {
+    let state = STATE.get(el);
+    if (state === undefined || state.listeners === 0) {
+        state = { mapped: isMapped(el), listeners: 0 };
+        STATE.set(el, state);
+        const ref = new WeakRef(el);
+        REFS.set(el, ref);
+        WATCHED.add(ref);
+        observe();
+    }
+    state.listeners++;
+    let watching = true;
+    return () => {
+        if (!watching) return;
+        watching = false;
+        const current = STATE.get(el)!;
+        if (--current.listeners > 0) return;
+        WATCHED.delete(REFS.get(el)!);
+        REFS.delete(el);
+        unobserve();
+    };
+}

package/src/widget-visible.spec.ts

@@ -0,0 +1,148 @@
+// `Gtk.Widget:visible` on a built element: an authored `visible: false`, `get_visible()` /
+// `set_visible()`, the property, and a breakpoint setter that writes it and restores it.
+import { describe, expect, it } from '@gjsify/unit';
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+
+import { Adw, Gtk } from './index.js';
+
+import { mountSharedTree } from './shared-tree-builder.js';
+
+function settle(): Promise<void> {
+    return new Promise((resolve) => {
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+    });
+}
+
+type Widget = HTMLElement & { visible: boolean; get_visible(): boolean; set_visible(value: boolean): void };
+
+const tree = (width: number, authored: boolean): SharedTreeNode => ({
+    tag: 'AdwApplicationWindow',
+    props: { 'default-width': width, 'default-height': 400 },
+    breakpoints: [
+        {
+            condition: 'max-width: 599sp',
+            setters: [{ object: 'target', property: 'visible', value: false }],
+        },
+    ],
+    children: [
+        {
+            tag: 'GtkBox',
+            slot: 'content',
+            children: [{ tag: 'GtkButton', id: 'target', props: authored ? {} : { visible: false } }],
+        },
+    ],
+});
+
+export const AdwWidgetVisibleTest = async () => {
+    await describe('adwaita-web: Gtk.Widget:visible on a built element', async () => {
+        await it('an authored `visible: false` hides the widget', () => {
+            const { root, unmount } = mountSharedTree({
+                tag: 'GtkBox',
+                children: [{ tag: 'GtkButton', id: 'b', props: { visible: false } }],
+            });
+            const button = root.querySelector('#b') as Widget;
+            expect(button.hidden).toBe(true);
+            expect(button.visible).toBe(false);
+            expect(button.get_visible()).toBe(false);
+            unmount();
+        });
+
+        await it('is visible by default, and an authored `true` shows it', () => {
+            const { root, unmount } = mountSharedTree({
+                tag: 'GtkBox',
+                children: [
+                    { tag: 'GtkButton', id: 'a' },
+                    { tag: 'GtkButton', id: 'b', props: { visible: true } },
+                ],
+            });
+            expect((root.querySelector('#a') as Widget).get_visible()).toBe(true);
+            expect((root.querySelector('#b') as Widget).hidden).toBe(false);
+            unmount();
+        });
+
+        await it('set_visible() and the property round-trip', () => {
+            const { root, unmount } = mountSharedTree({
+                tag: 'GtkBox',
+                children: [{ tag: 'GtkButton', id: 'b' }],
+            });
+            const button = root.querySelector('#b') as Widget;
+            button.set_visible(false);
+            expect(button.hidden).toBe(true);
+            button.visible = true;
+            expect(button.hidden).toBe(false);
+            expect(button.get_visible()).toBe(true);
+            unmount();
+        });
+
+        await it('a breakpoint setter hides the widget and unapplying restores it', async () => {
+            const narrow = mountSharedTree(tree(400, true));
+            await settle();
+            expect((narrow.root.querySelector('#target') as Widget).visible).toBe(false);
+            narrow.unmount();
+
+            const wide = mountSharedTree(tree(1000, true));
+            await settle();
+            expect((wide.root.querySelector('#target') as Widget).visible).toBe(true);
+            wide.unmount();
+        });
+
+        await it('unapplying a breakpoint restores an authored `false`', async () => {
+            const { root, unmount } = mountSharedTree(tree(1000, false));
+            await settle();
+            expect((root.querySelector('#target') as Widget).visible).toBe(false);
+            unmount();
+        });
+
+        await it('<gtk-stack-page> and <adw-sidebar> keep their own `visible`', () => {
+            const page = document.createElement('gtk-stack-page') as Widget;
+            page.visible = false;
+            expect(page.hasAttribute('hidden')).toBe(true);
+            const item = document.createElement('adw-sidebar-item') as Widget;
+            item.visible = false;
+            expect(item.getAttribute('visible')).toBe('false');
+            expect(item.hasAttribute('hidden')).toBe(true);
+        });
+    });
+
+    await describe('adwaita-web: Gtk.Widget:visible and tooltip-text on the element class', async () => {
+        await it('a created button has visible, get_visible and set_visible, typed on the class', () => {
+            const button: Gtk.Button = new Gtk.Button();
+            expect(button.visible).toBe(true);
+            button.set_visible(false);
+            expect(button.hidden).toBe(true);
+            expect(button.get_visible()).toBe(false);
+            button.visible = true;
+            expect(button.hasAttribute('hidden')).toBe(false);
+        });
+
+        await it('a created widget that is not a button has them too', () => {
+            const box = new Gtk.Box();
+            box.visible = false;
+            expect(box.hidden).toBe(true);
+            expect(box.get_visible()).toBe(false);
+        });
+
+        await it('a button has tooltip_text, tooltipText and get/set_tooltip_text over one attribute', () => {
+            const button = new Gtk.Button();
+            document.body.append(button);
+            expect(button.get_tooltip_text()).toBe(null);
+            button.set_tooltip_text('Copy');
+            expect(button.tooltip_text).toBe('Copy');
+            expect(button.tooltipText).toBe('Copy');
+            expect(button.getAttribute('tooltip-text')).toBe('Copy');
+            expect(button.querySelector('button')?.title).toBe('Copy');
+            button.tooltip_text = null;
+            expect(button.hasAttribute('tooltip-text')).toBe(false);
+            button.remove();
+        });
+
+        await it('a row has them and draws the tooltip on its parts', () => {
+            const row: Adw.ActionRow = new Adw.ActionRow();
+            document.body.append(row);
+            row.set_tooltip_text('Hint');
+            expect(row.get_tooltip_text()).toBe('Hint');
+            expect(row.querySelector('[title="Hint"]') !== null).toBe(true);
+            row.remove();
+        });
+    });
+};

package/src/window-maximize.spec.ts

@@ -0,0 +1,93 @@
+// A maximized or fullscreen `Gtk.Window` ignores its default size and fills the work area
+// (gtkwindow.c); on a page that is the frame's containing block. Driven through layout, because
+// the claim is about the box, not about a class name. One body for the three window elements.
+import { describe, expect, it } from '@gjsify/unit';
+
+import type { GtkWindow } from './elements/gtk-window.js';
+
+const TAGS = ['gtk-window', 'adw-window', 'adw-application-window'] as const;
+
+function mount(tag: string, attrs: Record<string, string> = {}): { el: GtkWindow; host: HTMLElement } {
+    const host = document.createElement('div');
+    host.style.cssText = 'position:relative;width:500px;height:400px';
+    document.body.appendChild(host);
+    const el = document.createElement(tag) as GtkWindow;
+    el.setAttribute('default-width', '360');
+    el.setAttribute('default-height', '240');
+    for (const [name, value] of Object.entries(attrs)) el.setAttribute(name, value);
+    host.appendChild(el);
+    return { el, host };
+}
+
+function size(el: HTMLElement): string {
+    const rect = el.getBoundingClientRect();
+    return `${Math.round(rect.width)}x${Math.round(rect.height)}`;
+}
+
+export const WindowMaximizeTest = async () => {
+    for (const tag of TAGS) {
+        await describe(`<${tag}> maximized fills its containing block`, async () => {
+            await it('opens at the default size, fills the box maximized, and restores on unmaximize', async () => {
+                const { el, host } = mount(tag);
+                expect(size(el)).toBe('360x240');
+                el.maximize();
+                expect(size(el)).toBe('500x400');
+                expect(el.style.width).toBe('');
+                el.unmaximize();
+                expect(size(el)).toBe('360x240');
+                host.remove();
+            });
+
+            await it('fills the box through the `maximized` property and `toggle-maximized`', async () => {
+                const { el, host } = mount(tag);
+                el.maximized = true;
+                expect(size(el)).toBe('500x400');
+                el.maximized = false;
+                expect(size(el)).toBe('360x240');
+                el.dispatchEvent(new CustomEvent('window-action', { detail: { action: 'toggle-maximized' } }));
+                expect(size(el)).toBe('500x400');
+                el.dispatchEvent(new CustomEvent('window-action', { detail: { action: 'toggle-maximized' } }));
+                expect(size(el)).toBe('360x240');
+                host.remove();
+            });
+
+            await it('fills the box fullscreened and restores on unfullscreen', async () => {
+                const { el, host } = mount(tag);
+                el.fullscreen();
+                expect(el.is_fullscreen()).toBe(true);
+                expect(size(el)).toBe('500x400');
+                el.unfullscreen();
+                expect(size(el)).toBe('360x240');
+                host.remove();
+            });
+
+            await it('stays filled until both states are gone', async () => {
+                const { el, host } = mount(tag);
+                el.maximize();
+                el.fullscreen();
+                el.unmaximize();
+                expect(size(el)).toBe('500x400');
+                el.unfullscreen();
+                expect(size(el)).toBe('360x240');
+                host.remove();
+            });
+
+            await it('fills the box already maximized when it is connected', async () => {
+                const { el, host } = mount(tag, { maximized: 'true' });
+                expect(size(el)).toBe('500x400');
+                host.remove();
+            });
+        });
+    }
+
+    await describe('<adw-window> maximized keeps its size request as a minimum', async () => {
+        await it('does not shrink below width-request/height-request', async () => {
+            const { el, host } = mount('adw-window', { 'width-request': '600', 'height-request': '450' });
+            el.maximize();
+            const [width, height] = size(el).split('x').map(Number);
+            expect(width >= 600).toBe(true);
+            expect(height >= 450).toBe(true);
+            host.remove();
+        });
+    });
+};

package/lib/types/icon-registry.d.ts

@@ -1,37 +0,0 @@
-/**
- * Make `name` drawable by every `.adw-icon` in the document, from an Adwaita symbolic SVG
- * source string (what `@gjsify/adwaita-icons` exports).
- *
- * BOTH arguments are checked and a wrong one THROWS rather than registering nothing: unlike
- * a render, this is an explicit call with a wrong argument, and silently doing nothing is
- * the failure mode this whole area exists to end. The name is normalized exactly as
- * `<gtk-image icon-name>` normalizes it — a single `-symbolic` suffix comes off, and the rest
- * must be one CSS token; the SVG has to parse to an `<svg>` root. `<gtk-image>` draws
- * `image-missing` for the same unusable name instead — there it came from markup, and
- * taking the page down over a typo is not proportionate.
- *
- * Registering a name the stylesheet already compiles is allowed and REPLACES the glyph:
- * the property is set on the document element, so it wins over the `:root` rule.
- *
- * CLIENT-SIDE ONLY: this touches `document.documentElement` and `document.head`, so at
- * module top level in an SSR/SSG build it throws before a page is rendered.
- */
-export declare function registerIcon(name: string, svg: string): void;
-/**
- * Whether `name` draws something other than `image-missing` — a symbolic glyph compiled into
- * the stylesheet or registered at runtime, or a colour icon from `registerColorIcon`. The
- * name is looked up exactly as `<gtk-image icon-name>` looks it up (`icon-theme.ts`).
- *
- * Reads the live cascade rather than a generated list, so it answers for a glyph that
- * arrived by any route, including a consumer's own `--icon-<name>` declaration. It is
- * deliberately the CUSTOM PROPERTY that is read and not the rendered `mask-image` of a
- * probe element: since `_icon.scss` gives every icon box the `image-missing` fallback,
- * a rendered mask is never `none`, and comparing against the fallback would answer
- * `false` for `image-missing` itself — the one name where being drawn and having fallen
- * back look identical.
- *
- * Narrowing worth knowing: a consumer who writes `.adw-icon--x { mask-image: url(…) }`
- * with no matching `--icon-x` gets `false` here and a drawn icon anyway. The generator and
- * {@link registerIcon} are the two things that create the pair, and both create both.
- */
-export declare function isIconAvailable(name: string): boolean;