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

package/src/elements/gtk-stack.ts

@@ -92,6 +92,7 @@
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
 import type { DispatchedSignals } from '../signals.js';
+import { STACK_PAGE_ATTRIBUTES, pageChildOf } from './gtk-stack-page.js';
 
 /** `GtkStackTransitionType`, spelled as the GIR's enum nicks (gtkstack.c:95-121). */
 export type StackTransitionType =
@@ -416,7 +417,7 @@ export class GtkStack extends HTMLElement {
         }
         this._initialized = true;
         this.setAttribute('role', 'group');
-        for (const child of this._children()) this._initChild(child);
+        for (const child of this._children()) this._initChild(this._adopt(child));
         // `add_page` connects the stack to each page's `notify::visible`
         // (gtkstack.c:1771), which is the browser's mutation observer.
         this._observer = new MutationObserver((records) => this._onChildMutations(records));
@@ -531,12 +532,44 @@ export class GtkStack extends HTMLElement {
         return this._children().find((child) => this._page(child).visible) ?? null;
     }
 
+    /**
+     * A `<gtk-stack-page>` record, adopted: its child takes the record's place and its properties
+     * as the attributes this element reads, the way `<adw-view-stack>` adopts a declared page.
+     * Any other child is already the page and is handed back as it is.
+     */
+    private _adopt(child: HTMLElement): HTMLElement {
+        if (child.localName !== 'gtk-stack-page') return child;
+        const content = pageChildOf(child);
+        if (content === null) {
+            throw new Error(
+                `<gtk-stack-page name="${child.getAttribute('name') ?? ''}"> has no child, so the stack would ` +
+                    'hold a page with nothing to show.',
+            );
+        }
+        for (const name of STACK_PAGE_ATTRIBUTES) {
+            const value = child.getAttribute(name);
+            if (value !== null) content.setAttribute(name, value);
+        }
+        if (child.hasAttribute('hidden')) content.setAttribute('hidden', '');
+        content.removeAttribute('slot');
+        this.replaceChild(content, child);
+        return content;
+    }
+
     private _initChild(child: HTMLElement): void {
         if (this._initializedChildren.has(child)) return;
         this._initializedChildren.add(child);
         child.classList.add('adw-stack-page');
     }
 
+    /**
+     * The observer watches the subtree, so an attribute record can come from anything below a
+     * page; only a direct child is a page of THIS stack (a nested stack's pages are its own).
+     */
+    private _isPage(node: Node): boolean {
+        return node.parentNode === this;
+    }
+
     private _onChildMutations(records: MutationRecord[]): void {
         let added = 0;
         let removed = 0;
@@ -544,13 +577,24 @@ export class GtkStack extends HTMLElement {
         let pageUpdated = false;
         for (const record of records) {
             if (record.type === 'childList') {
+                // The observer watches the subtree for page attributes; a child list changing
+                // below a page (an adopted record handing over its child) is not a page change.
+                if (record.target !== this) continue;
                 for (const node of Array.from(record.removedNodes)) {
+                    // A record leaving as its child takes its place was never a page here.
+                    if (node instanceof HTMLElement && node.localName === 'gtk-stack-page') continue;
                     if (node === this._visible) this._visible = null;
                     if (node === this._lastVisible) this._lastVisible = null;
                     removed += 1;
                 }
                 for (const node of Array.from(record.addedNodes)) {
                     if (!(node instanceof HTMLElement)) continue;
+                    // An adopted record is replaced by its child, and that replacement is the
+                    // childList record the page is counted in.
+                    if (node.localName === 'gtk-stack-page') {
+                        if (node.parentElement === this) this._adopt(node);
+                        continue;
+                    }
                     this._initChild(node);
                     added += 1;
                     if (position === -1) position = this._children().indexOf(node);
@@ -558,13 +602,14 @@ export class GtkStack extends HTMLElement {
                 continue;
             }
             const name = record.attributeName;
-            if (!name) continue;
+            if (!name || !this._isPage(record.target)) continue;
             if (name === 'hidden') {
                 // `stack_child_visibility_notify_cb` (gtkstack.c:1617-1633) re-runs
                 // `update_child_visible`: hiding the visible page falls back to the first
                 // visible one (which is what the NULL means, :1437-1450), and showing one
-                // while none is visible picks it up (:3147-3149).
-                this._show(this._firstVisible());
+                // while none is visible picks it up (:3147-3149). Any other change leaves
+                // the selection where it is.
+                if (!this._visible || !this._page(this._visible).visible) this._show(this._firstVisible());
                 continue;
             }
             if (PAGE_ATTRIBUTES.includes(name)) pageUpdated = true;
@@ -579,7 +624,7 @@ export class GtkStack extends HTMLElement {
         }
         if (pageUpdated) {
             for (const record of records) {
-                if (record.type !== 'attributes') continue;
+                if (record.type !== 'attributes' || !this._isPage(record.target)) continue;
                 const target = record.target as HTMLElement;
                 this.dispatchEvent(new CustomEvent('page-updated', { bubbles: true, detail: { child: target } }));
                 // `gtk_stack_page_set_name` re-notifies `visible-child-name` when the

package/src/elements/gtk-tree-expander.ts

@@ -59,6 +59,7 @@ import {
 } from '@gjsify/adwaita-core';
 
 import { createGtkImage } from './gtk-image.js';
+import { bindSlottedChildren } from '../slotted-children.js';
 
 /** `TIMEOUT_EXPAND` — how long a drag hovers before the row opens (gtktreeexpander.c:717). */
 const TIMEOUT_EXPAND = 500;
@@ -142,6 +143,8 @@ export class GtkTreeExpander extends HTMLElement {
             if (!this.hasAttribute('tabindex')) this.tabIndex = 0;
             this._wire();
         }
+        // The NAME only, for the reason `adw-bin.ts` gives: the child already IS the content.
+        bindSlottedChildren(this, [{ name: 'child', into: this }]);
         this.setAttribute('role', 'button');
         this._render();
     }

package/src/elements/gtk-viewport.ts

@@ -65,6 +65,8 @@
 
 import { clampAdjustmentValue, normalizeAdjustment, type AdwAdjustment } from '@gjsify/adwaita-core';
 
+import { bindSlottedChildren } from '../slotted-children.js';
+
 /** `viewport_set_adjustment_values`'s two fractions of the visible size. */
 const STEP_FRACTION = 0.1;
 const PAGE_FRACTION = 0.9;
@@ -130,6 +132,8 @@ export class GtkViewport extends HTMLElement {
     }
 
     connectedCallback() {
+        // The NAME only, for the reason `adw-bin.ts` gives: the child already IS the content.
+        bindSlottedChildren(this, [{ name: 'child', into: this }]);
         this.setAttribute('role', 'generic');
         // `scroll` does not bubble, so the platform's own is heard here, on the node that
         // raised it, and re-announced as GTK's `GtkAdjustment::value-changed`.

package/src/elements/gtk-window-handle.ts

@@ -46,6 +46,8 @@
 // Copyright (c) The GTK Team. LGPLv2.1+.
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
+import { bindSlottedChildren } from '../slotted-children.js';
+
 /** `GtkTitlebarGesture`'s three gestures, as `perform_titlebar_action` decides them. */
 export type GtkTitlebarGesture = 'double-click' | 'middle-click' | 'right-click';
 
@@ -146,6 +148,8 @@ export class GtkWindowHandle extends HTMLElement {
     }
 
     connectedCallback() {
+        // The NAME only, for the reason `adw-bin.ts` gives: the child already IS the content.
+        bindSlottedChildren(this, [{ name: 'child', into: this }]);
         this.setAttribute('role', 'generic');
         this.addEventListener('click', this._onClick);
         this.addEventListener('pointerdown', this._onPointerDown);

package/src/elements/gtk-window.ts

@@ -47,7 +47,7 @@
 // difference a reader of the DOM can see.
 //
 // NOT PORTED, and why — these are the KNOWN_GAPS of this element:
-//   `application`, `child`, `default-widget`, `display` — WIDGET- or
+//   `child`, `default-widget`, `display` — WIDGET- or
 //     DISPLAY-typed, so a slot or an id here rather than an attribute; `child` and
 //     `titlebar` ARE slots and `transient-for` only has to be PRESENT.
 //   `destroy-with-parent` — a DOM node has no destroy, and a page has no parent to destroy.
@@ -69,8 +69,14 @@
 //                    `set_focus(el)` calls `el.focus()` and refuses an element outside the frame;
 //                    `set_focus(null)` blurs. `focusin`/`focusout` notify; focus that merely
 //                    leaves with the window (blur) keeps its widget, as GTK keeps it.
-//   `maximized`    — the FRAME's state (square corners), not the browser window's: a page cannot
-//                    maximize its browser window. `is_maximized()` reads it.
+//   `maximized`    — the FRAME's state, not the browser window's: a page cannot maximize its
+//                    browser window. Square corners, and — as in GTK, where a maximized or
+//                    fullscreen window ignores its default size and fills the work area — the frame
+//                    fills its CONTAINING BLOCK (the viewport for a frame in a full-height body)
+//                    until it is unmaximized, which restores `default-width`/`default-height`.
+//                    `fullscreened` does the same. `maximize()`, `unmaximize()`, `fullscreen()`,
+//                    `unfullscreen()` and `toggle-maximized` all write the attribute. `is_maximized()`
+//                    reads it.
 //   `present()`    — un-hides the frame; a page cannot raise or focus a window it does not own.
 //
 // THE GOBJECT DOOR (ADR 0096 § 3, ADR 0098 Amendment 3): `connect` / `disconnect` / `emit` /
@@ -92,6 +98,7 @@
 
 import { CloseRequestState, WindowMemberState, type WindowMemberProperty } from '@gjsify/adwaita-core';
 
+import { defineWindowApplication, type GtkApplication } from '../application.js';
 import { installElementApi } from '../gobject-elements.js';
 import type { DispatchedSignals } from '../signals.js';
 import { bindSlottedChildren, type AdwSlot } from '../slotted-children.js';
@@ -99,6 +106,7 @@ import { bindSlottedChildren, type AdwSlot } from '../slotted-children.js';
 // Registers <gtk-window-controls>: a frame with no titlebar of its own draws the two of them
 // a server-side decoration would have, so importing the window alone must define them.
 import './gtk-window-controls.js';
+import { fillsContainingBlock } from './adw-window-features.js';
 import type { WindowAction } from './gtk-window-controls.js';
 
 export class GtkWindow extends HTMLElement {
@@ -138,6 +146,7 @@ export class GtkWindow extends HTMLElement {
         'close-request': 'close-request',
         ...Object.fromEntries(
             [
+                'application',
                 'decorated',
                 'default-height',
                 'default-width',
@@ -156,6 +165,11 @@ export class GtkWindow extends HTMLElement {
         ),
     };
 
+    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
+    declare application: GtkApplication | null;
+    declare get_application: () => GtkApplication | null;
+    declare set_application: (application: GtkApplication | null) => void;
+
     /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
     declare connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
     /** `GObject.Object.disconnect`: throws for an id that is not connected. */
@@ -239,6 +253,15 @@ export class GtkWindow extends HTMLElement {
         this._write('maximized', String(value));
     }
 
+    /** `Gtk.Window:fullscreened` — square corners, and the frame fills its containing block. */
+    get fullscreened(): boolean {
+        return this._offByDefault('fullscreened');
+    }
+
+    set fullscreened(value: boolean) {
+        this._write('fullscreened', String(value));
+    }
+
     /** `Gtk.Window:resizable` — whether the maximize button may appear. */
     get resizable(): boolean {
         return this._onByDefault('resizable');
@@ -300,7 +323,14 @@ export class GtkWindow extends HTMLElement {
         this._content.className = 'adw-gtk-window-content';
 
         bindSlottedChildren(this, [
-            ...(this.hasTitlebar() ? [{ name: 'titlebar', into: this._titlebar }] : []),
+            // `child` only beside a titlebar: AdwWindow and AdwApplicationWindow inherit
+            // `Gtk.Window:child` and abort on it (adw-window.c:180), `content` is theirs.
+            ...(this.hasTitlebar()
+                ? [
+                      { name: 'titlebar', into: this._titlebar },
+                      { name: 'child', into: this._content },
+                  ]
+                : []),
             ...this.extraSlots(),
             { into: this._content },
         ]).install(...this.strips());
@@ -431,16 +461,18 @@ export class GtkWindow extends HTMLElement {
 
     /**
      * The frame's box from `default-width` / `default-height`; an absent one clears it. A subclass
-     * with a size request of its own (`Adw.Window`'s 360×200) replaces this.
+     * with a size request of its own (`Adw.Window`'s 360×200) replaces this. A maximized or
+     * fullscreened frame carries no inline size: the skin fills its containing block.
      */
     protected renderFrameSize(): void {
+        const fills = fillsContainingBlock(this);
         const width = Number.parseFloat(this.getAttribute('default-width') ?? '');
         const height = Number.parseFloat(this.getAttribute('default-height') ?? '');
         for (const [axis, value] of [
             ['width', width],
             ['height', height],
         ] as const) {
-            if (Number.isFinite(value) && value > 0) this.style.setProperty(axis, `${value}px`);
+            if (!fills && Number.isFinite(value) && value > 0) this.style.setProperty(axis, `${value}px`);
             else this.style.removeProperty(axis);
         }
     }
@@ -598,6 +630,23 @@ export class GtkWindow extends HTMLElement {
     unmaximize(): void {
         this._write('maximized', 'false');
     }
+
+    /** `gtk_window_is_fullscreen`: the FRAME's state, like {@link is_maximized}. */
+    is_fullscreen(): boolean {
+        return this.fullscreened;
+    }
+
+    /** `gtk_window_fullscreen`; asynchronous in GTK, so the property is written directly. */
+    fullscreen(): void {
+        this._write('fullscreened', 'true');
+    }
+
+    /** `gtk_window_unfullscreen`, with the same caveat as {@link fullscreen}. */
+    unfullscreen(): void {
+        this._write('fullscreened', 'false');
+    }
 }
 
 customElements.define('gtk-window', GtkWindow);
+
+defineWindowApplication(GtkWindow.prototype);

package/src/gobject-elements.ts

@@ -154,6 +154,34 @@ export function installSensitive(el: HTMLElement): void {
     });
 }
 
+const VISIBLE_INSTALLED = new WeakSet<Element>();
+
+/** Whether `installVisible` gave `el` its `visible` (an element with its own keeps its own). */
+export function hasInstalledVisible(el: Element): boolean {
+    return VISIBLE_INSTALLED.has(el);
+}
+
+/**
+ * `Gtk.Widget:visible` for an element that has no member of that name: `gtk_widget_get_visible`
+ * and `gtk_widget_set_visible` over the DOM's `hidden` attribute, TRUE until hidden as GtkWidget's
+ * default is. It notifies only where the element declares `notify::visible`. An element that already declares `visible` (`<gtk-stack-page>`, `<adw-sidebar>`)
+ * keeps its own, and so does a registered class whose prototype has the port's members.
+ */
+export function installVisible(el: HTMLElement): void {
+    if ('visible' in el) return;
+    VISIBLE_INSTALLED.add(el);
+    const define = (name: string, descriptor: PropertyDescriptor) =>
+        Object.defineProperty(el, name, { configurable: true, enumerable: false, ...descriptor });
+    const set = (value: unknown): void => {
+        const before = !el.hidden;
+        el.toggleAttribute('hidden', !value);
+        if (!el.hidden !== before && 'notify::visible' in dispatchedSignalsOf(el)) notifyElement(el, 'visible');
+    };
+    define('visible', { get: () => !el.hidden, set });
+    if (!('get_visible' in el)) define('get_visible', { value: () => !el.hidden, writable: true });
+    if (!('set_visible' in el)) define('set_visible', { value: set, writable: true });
+}
+
 /** Gives `el` the instance API of a registered class, over the events it declares. */
 export function installElementApi(el: HTMLElement): void {
     // A registered class already has the core's four methods on its prototype.

package/src/gtk-stack.spec.ts

@@ -7,6 +7,8 @@
 import { describe, expect, it } from '@gjsify/unit';
 
 import type { GtkStack } from './elements/gtk-stack.js';
+import { pageChildOf } from './elements/gtk-stack-page.js';
+import { mountSharedTree } from './shared-tree-builder.js';
 
 interface Page {
     name: string;
@@ -144,6 +146,66 @@ export const GtkStackTest = async () => {
             host.remove();
         });
 
+        await it('a descendant toggling hidden keeps the selection', async () => {
+            // gtkstack.c:1617-1633 listens to the PAGE's own visibility, never to what is
+            // nested inside it (an `adw-view-stack` showing and hiding its own pages).
+            const { el, host } = mount([
+                { name: 'single', title: 'Single' },
+                { name: 'three', title: 'Three' },
+            ]);
+            const nested = document.createElement('span');
+            el.children[0]!.appendChild(nested);
+            el.setVisibleChildName('three');
+            nested.setAttribute('hidden', '');
+            await settle();
+            nested.removeAttribute('hidden');
+            await settle();
+            expect(el.visibleChildName).toBe('three');
+            expect(marks(el)).toStrictEqual(['single', 'three:visible']);
+            host.remove();
+        });
+
+        await it('hiding a page that is not visible keeps the selection', async () => {
+            const { el, host } = mount([
+                { name: 'a', title: 'Alpha' },
+                { name: 'b', title: 'Beta' },
+                { name: 'c', title: 'Gamma' },
+            ]);
+            el.setVisibleChildName('c');
+            (el.children[1] as HTMLElement).setAttribute('hidden', '');
+            await settle();
+            expect(el.visibleChildName).toBe('c');
+            host.remove();
+        });
+
+        await it('hiding the visible page after a selection falls back to the first visible', async () => {
+            const { el, host } = mount([
+                { name: 'a', title: 'Alpha' },
+                { name: 'b', title: 'Beta' },
+                { name: 'c', title: 'Gamma' },
+            ]);
+            el.setVisibleChildName('c');
+            (el.children[0] as HTMLElement).setAttribute('hidden', '');
+            (el.children[2] as HTMLElement).setAttribute('hidden', '');
+            await settle();
+            expect(el.visibleChildName).toBe('b');
+            host.remove();
+        });
+
+        await it('a descendant name change dispatches no page-updated', async () => {
+            const { el, host } = mount([{ name: 'a', title: 'Alpha' }]);
+            const nested = document.createElement('span');
+            el.children[0]!.appendChild(nested);
+            await settle();
+            const events: string[] = [];
+            el.addEventListener('page-updated', () => events.push('updated'));
+            nested.setAttribute('name', 'inner');
+            await settle();
+            expect(events).toStrictEqual([]);
+            expect(el.visibleChildName).toBe('a');
+            host.remove();
+        });
+
         await it('re-selecting the visible page is not a change', () => {
             // gtkstack.c:1452-1453 — no notify, no transition.
             const { el, host } = mount([
@@ -429,4 +491,112 @@ export const GtkStackTest = async () => {
             host.remove();
         });
     });
+
+    await describe('<gtk-stack> adopts a <gtk-stack-page> record', async () => {
+        const record = (attrs: Record<string, string>, body = 'page'): HTMLElement => {
+            const page = document.createElement('gtk-stack-page');
+            for (const [name, value] of Object.entries(attrs)) page.setAttribute(name, value);
+            const child = document.createElement('div');
+            child.setAttribute('slot', 'child');
+            child.textContent = body;
+            page.appendChild(child);
+            return page;
+        };
+
+        await it('puts the child where the record was, with its properties as attributes', () => {
+            const host = document.createElement('div');
+            document.body.appendChild(host);
+            const el = document.createElement('gtk-stack') as GtkStack;
+            el.appendChild(
+                record({
+                    name: 'a',
+                    title: 'Alpha',
+                    'icon-name': 'go-home',
+                    'needs-attention': '',
+                    'use-underline': '',
+                }),
+            );
+            el.appendChild(record({ name: 'b' }, 'beta'));
+            host.appendChild(el);
+            expect(el.querySelector('gtk-stack-page')).toBe(null);
+            expect(marks(el)).toStrictEqual(['a:visible', 'b']);
+            const [page] = el.pages;
+            expect(page!.title).toBe('Alpha');
+            expect(page!.iconName).toBe('go-home');
+            expect(page!.needsAttention).toBe(true);
+            expect(page!.useUnderline).toBe(true);
+            expect(page!.child.hasAttribute('slot')).toBe(false);
+            expect(el.getChildByName('b')!.textContent).toBe('beta');
+            host.remove();
+        });
+
+        await it('reads a hidden record as GtkStackPage:visible = FALSE', () => {
+            const host = document.createElement('div');
+            document.body.appendChild(host);
+            const el = document.createElement('gtk-stack') as GtkStack;
+            const hidden = record({ name: 'a' });
+            (hidden as unknown as { visible: boolean }).visible = false;
+            el.appendChild(hidden);
+            el.appendChild(record({ name: 'b' }));
+            host.appendChild(el);
+            expect(el.pages.map((page) => page.visible)).toStrictEqual([false, true]);
+            expect(el.visibleChildName).toBe('b');
+            host.remove();
+        });
+
+        await it('adopts a record appended after connect, counted once', async () => {
+            const { el, host } = mount([{ name: 'a' }]);
+            const events: unknown[] = [];
+            el.addEventListener('items-changed', (e) => events.push((e as CustomEvent).detail));
+            el.appendChild(record({ name: 'b' }));
+            await settle();
+            await settle();
+            expect(marks(el)).toStrictEqual(['a:visible', 'b']);
+            expect(events).toStrictEqual([{ position: 1, removed: 0, added: 1 }]);
+            host.remove();
+        });
+
+        await it('takes a bare child as the page, and refuses a record with two', () => {
+            const bare = document.createElement('gtk-stack-page');
+            const child = document.createElement('div');
+            bare.appendChild(child);
+            expect(pageChildOf(bare)).toBe(child);
+            bare.appendChild(document.createElement('div'));
+            expect(() => pageChildOf(bare)).toThrow('has one `child`');
+            expect(pageChildOf(document.createElement('gtk-stack-page'))).toBe(null);
+        });
+
+        await it('builds `Stack { StackPage { name; child: … } }` from a shared tree', () => {
+            const { root, unmount } = mountSharedTree({
+                tag: 'GtkStack',
+                id: 'layoutHost',
+                children: [
+                    {
+                        tag: 'GtkStackPage',
+                        id: 'singlePage',
+                        props: { name: 'single' },
+                        children: [{ tag: 'AdwBin', slot: 'child', id: 'singleBin' }],
+                    },
+                    {
+                        tag: 'GtkStackPage',
+                        id: 'threePage',
+                        props: { name: 'three', title: 'Three' },
+                        children: [{ tag: 'AdwBin', slot: 'child', id: 'threeBin' }],
+                    },
+                ],
+            });
+            try {
+                const stack = root as GtkStack;
+                expect(stack.pages.map((page) => page.child.id)).toStrictEqual(['singleBin', 'threeBin']);
+                // The first page added is the visible one (gtkstack.c:1773-1775); a breakpoint
+                // setter selects another by the name its record carried.
+                expect(stack.visibleChild!.id).toBe('singleBin');
+                expect(stack.setVisibleChildName('three')).toBe(true);
+                expect(stack.visibleChild!.id).toBe('threeBin');
+                expect(stack.getPage(stack.visibleChild!)!.title).toBe('Three');
+            } finally {
+                unmount();
+            }
+        });
+    });
 };

package/src/index.ts

@@ -80,8 +80,8 @@ export type { AdwUndershootEdges } from './scroll-shading.js';
 // replaying an authored tree — a storybook fixture, a devtools probe, the shared-trees
 // spec itself — has a route to it that is not a `.spec.ts` import; see that file's header
 // for why `mountSharedTree` and not `buildSharedTree` alone is the instantiation half.
-export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
-export type { MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
+export { buildSharedTree, buildWithSiblings, mountSharedTree } from './shared-tree-builder.js';
+export type { BuildOptions, BuiltTree, MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
 export { registerTemplateClass } from './template-classes.js';
 
 // The stylesheet compiles a chosen SUBSET of `@gjsify/adwaita-icons` (the whole set is

package/src/keyboard-operable.spec.ts

@@ -314,8 +314,8 @@ export const AdwKeyboardOperableTest = async () => {
                 '<adw-alert-response id="ok">OK</adw-alert-response>' +
                     '<adw-alert-response id="cancel">Cancel</adw-alert-response>',
             );
-            el.setDefaultResponse('ok');
-            el.setResponseEnabled('ok', false);
+            el.set_default_response('ok');
+            el.set_response_enabled('ok', false);
             opener.focus();
             el.setAttribute('open', '');
 
@@ -344,7 +344,7 @@ export const AdwKeyboardOperableTest = async () => {
                     '<adw-alert-response id="ok">OK</adw-alert-response>' +
                     '<adw-alert-response id="cancel">Cancel</adw-alert-response>',
             );
-            el.setDefaultResponse('ok');
+            el.set_default_response('ok');
             el.setAttribute('open', '');
 
             // `adw_alert_dialog_grab_focus` tries the CONTENT first (adw-alert-dialog.c:397)