@gjsify/adwaita-web 0.45.0 → 0.46.0

package/src/{adw-button.spec.ts → gtk-button.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-button>'s style classes.
+// DOM-level tests for <gtk-button>'s style classes.
 //
 // The element and its NativeScript twin each kept their own attribute→class table,
 // and the two disagreed: `circular` was here and not there. The table now lives in
@@ -13,7 +13,7 @@ const WEB_ATTRIBUTES = new Set(['flat', 'suggested', 'destructive', 'circular',
 
 /** Mount a button carrying the given boolean attributes; return the inner classes. */
 function mountWithStyles(names: readonly string[]): string[] {
-    const el = document.createElement('adw-button');
+    const el = document.createElement('gtk-button');
     el.setAttribute('label', 'Click me');
     for (const name of names) el.setAttribute(name, '');
     document.body.appendChild(el);
@@ -22,10 +22,10 @@ function mountWithStyles(names: readonly string[]): string[] {
 }
 
 function unmountAll(): void {
-    for (const el of Array.from(document.querySelectorAll('adw-button'))) el.remove();
+    for (const el of Array.from(document.querySelectorAll('gtk-button'))) el.remove();
 }
 
-export const AdwButtonTest = async () => {
+export const GtkButtonTest = async () => {
     // Rows naming a class the LONG way (`suggested-action`) are the NativeScript
     // variant spelling — this element has no such attribute. They are partitioned
     // out here rather than skipped inside the loop, and the partition is asserted,
@@ -33,7 +33,7 @@ export const AdwButtonTest = async () => {
     const reachable = BUTTON_STYLE_CLASS_VECTORS.filter((v) => v.names.every((n) => WEB_ATTRIBUTES.has(n)));
     const unreachable = BUTTON_STYLE_CLASS_VECTORS.filter((v) => !v.names.every((n) => WEB_ATTRIBUTES.has(n)));
 
-    await describe('<adw-button> style classes', async () => {
+    await describe('<gtk-button> style classes', async () => {
         for (const { names, classes, rule } of reachable) {
             await it(`[${names.join(', ')}] → [${classes.join(', ')}] — ${rule}`, () => {
                 expect(mountWithStyles(names)).toStrictEqual([...classes]);
@@ -47,7 +47,7 @@ export const AdwButtonTest = async () => {
         });
 
         await it('a style attribute added later is picked up', () => {
-            const el = document.createElement('adw-button');
+            const el = document.createElement('gtk-button');
             el.setAttribute('label', 'Send');
             document.body.appendChild(el);
             el.setAttribute('suggested', '');

package/src/{adw-drop-down.spec.ts → gtk-drop-down.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level behaviour tests for <adw-drop-down>, in a real browser via the
+// DOM-level behaviour tests for <gtk-drop-down>, in a real browser via the
 // @gjsify/adwaita-web browser test axis.
 //
 // The SELECTION half is driven by the SAME table the NativeScript renderer asserts
@@ -14,21 +14,21 @@ import { describe, it, expect } from '@gjsify/unit';
 import { COMBO_SELECTION_VECTORS } from '@gjsify/adwaita-core/conformance';
 import type { ComboSelectionStep, ComboSelectionVector } from '@gjsify/adwaita-core/conformance';
 
-import type { AdwDropDown } from './elements/adw-drop-down.js';
+import type { GtkDropDown } from './elements/gtk-drop-down.js';
 
-function makeDropDown(): AdwDropDown {
-    const el = document.createElement('adw-drop-down') as AdwDropDown;
+function makeDropDown(): GtkDropDown {
+    const el = document.createElement('gtk-drop-down') as GtkDropDown;
     document.body.appendChild(el);
     return el;
 }
 
 /** The text the closed button shows — the rendered `selectedLabel`. */
-function labelText(dd: AdwDropDown): string {
+function labelText(dd: GtkDropDown): string {
     return dd.querySelector('.adw-drop-down-label')?.textContent ?? '';
 }
 
 /** Open the chooser the way a user does. A no-op over an empty model, as the element guards. */
-function openChooser(dd: AdwDropDown): void {
+function openChooser(dd: GtkDropDown): void {
     (dd.querySelector('.adw-drop-down-button') as HTMLButtonElement).click();
 }
 
@@ -36,7 +36,7 @@ function openChooser(dd: AdwDropDown): void {
  * Replay one vector step against the real element — property sets for the
  * programmatic ops, a popover gesture for the interactive one.
  */
-function applyStep(dd: AdwDropDown, step: ComboSelectionStep): void {
+function applyStep(dd: GtkDropDown, step: ComboSelectionStep): void {
     switch (step.op) {
         case 'setOptions':
             dd.options = step.options;
@@ -78,15 +78,15 @@ function vectorNamed(name: string): ComboSelectionVector {
 }
 
 /** Mount a drop-down and record every `change` detail it dispatches. */
-function mountRecording(): { dd: AdwDropDown; changes: unknown[] } {
+function mountRecording(): { dd: GtkDropDown; changes: unknown[] } {
     const dd = makeDropDown();
     const changes: unknown[] = [];
     dd.addEventListener('change', (event) => changes.push((event as CustomEvent).detail));
     return { dd, changes };
 }
 
-export const AdwDropDownTest = async () => {
-    await describe('adw-drop-down selection (libadwaita conformance vectors)', async () => {
+export const GtkDropDownTest = async () => {
+    await describe('gtk-drop-down selection (libadwaita conformance vectors)', async () => {
         for (const vector of COMBO_SELECTION_VECTORS) {
             if (vector.name === DROP_DOWN_REJECTS) continue;
 
@@ -129,7 +129,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down options', async () => {
+    await describe('gtk-drop-down options', async () => {
         await it('accepts a string[] (value === label)', async () => {
             const dd = makeDropDown();
             dd.options = ['One', 'Two', 'Three'];
@@ -152,7 +152,7 @@ export const AdwDropDownTest = async () => {
         });
 
         await it('parses options from the JSON attribute', async () => {
-            const dd = document.createElement('adw-drop-down') as AdwDropDown;
+            const dd = document.createElement('gtk-drop-down') as GtkDropDown;
             dd.setAttribute('options', '[{"value":"x","label":"Ex"},{"value":"y","label":"Why"}]');
             dd.setAttribute('selected', '1');
             document.body.appendChild(dd);
@@ -170,7 +170,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down selected ↔ value sync', async () => {
+    await describe('gtk-drop-down selected ↔ value sync', async () => {
         await it('selectedValue setter finds the index by value', async () => {
             const dd = makeDropDown();
             dd.options = [
@@ -205,7 +205,7 @@ export const AdwDropDownTest = async () => {
         await it('setting options + selected before connect does not crash + applies on connect', async () => {
             // The property setters can run BEFORE connectedCallback builds the DOM, where
             // _updateLabel would touch an undefined label element.
-            const dd = document.createElement('adw-drop-down') as AdwDropDown;
+            const dd = document.createElement('gtk-drop-down') as GtkDropDown;
             dd.options = ['a', 'b', 'c'];
             dd.selected = 2;
             expect(dd.isConnected).toBe(false);
@@ -217,7 +217,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down notify-on-change', async () => {
+    await describe('gtk-drop-down notify-on-change', async () => {
         await it('a programmatic set fires notify::selected but NOT change (DOM <select> semantics)', async () => {
             const dd = makeDropDown();
             dd.options = ['a', 'b', 'c'];
@@ -259,7 +259,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down popover behaviour', async () => {
+    await describe('gtk-drop-down popover behaviour', async () => {
         await it('opens on button click and closes on outside pointerdown', async () => {
             const dd = makeDropDown();
             dd.options = ['a', 'b'];
@@ -286,7 +286,7 @@ export const AdwDropDownTest = async () => {
         });
     });
 
-    await describe('adw-drop-down search', async () => {
+    await describe('gtk-drop-down search', async () => {
         await it('renders a search entry and filters the list', async () => {
             const dd = makeDropDown();
             dd.options = ['Apple', 'Banana', 'Cherry'];

package/src/{adw-entry.spec.ts → gtk-entry.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-entry>'s length arithmetic.
+// DOM-level tests for <gtk-entry>'s length arithmetic.
 //
 // The element had NO max length and no text length, while its NativeScript twin has
 // composed `@gjsify/adwaita-core`'s since it shipped — so the same consumer got a
@@ -10,22 +10,22 @@
 import { describe, expect, it } from '@gjsify/unit';
 import { ENTRY_MAX_LENGTH_VECTORS, ENTRY_TEXT_LENGTH_VECTORS } from '@gjsify/adwaita-core/conformance';
 
-import type { AdwEntry } from './elements/adw-entry.js';
+import type { GtkEntry } from './elements/gtk-entry.js';
 
 /** Mount an entry with the given attributes. */
-function mountEntry(attrs: Record<string, string> = {}): AdwEntry {
-    const entry = document.createElement('adw-entry') as AdwEntry;
+function mountEntry(attrs: Record<string, string> = {}): GtkEntry {
+    const entry = document.createElement('gtk-entry') as GtkEntry;
     for (const [name, value] of Object.entries(attrs)) entry.setAttribute(name, value);
     document.body.appendChild(entry);
     return entry;
 }
 
 function unmountAll(): void {
-    for (const entry of Array.from(document.querySelectorAll('adw-entry'))) entry.remove();
+    for (const entry of Array.from(document.querySelectorAll('gtk-entry'))) entry.remove();
 }
 
-export const AdwEntryTest = async () => {
-    await describe('<adw-entry> text length', async () => {
+export const GtkEntryTest = async () => {
+    await describe('<gtk-entry> text length', async () => {
         for (const { text, length, rule } of ENTRY_TEXT_LENGTH_VECTORS) {
             await it(`${JSON.stringify(text)} → ${length} — ${rule}`, () => {
                 const entry = mountEntry();
@@ -36,7 +36,7 @@ export const AdwEntryTest = async () => {
         }
     });
 
-    await describe('<adw-entry> max length', async () => {
+    await describe('<gtk-entry> max length', async () => {
         for (const { text, maxLength, clamped, length, rule } of ENTRY_MAX_LENGTH_VECTORS) {
             await it(`${JSON.stringify(text)} @ ${maxLength} — ${rule}`, () => {
                 const entry = mountEntry({ maxlength: String(maxLength) });

package/src/{adw-icon.spec.ts → gtk-image.spec.ts}

@@ -1,17 +1,17 @@
-// DOM-level tests for <adw-icon>, driven by the SAME `normalizeIconName` vectors the
+// DOM-level tests for <gtk-image>, driven by the SAME `normalizeIconName` vectors the
 // core suite asserts against (`@gjsify/adwaita-core/conformance`).
 //
 // The icon-name class must never be built by hand: a name is only usable once it is
 // known to be a SINGLE CSS token, and hand-built spans skipped that check, so
 // `icon-name="a b"` interpolated a stray second class and shipped it through
-// `<adw-menu-button>` for its own icon and for every JSON menu entry's. The vectors run
+// `<gtk-menu-button>` for its own icon and for every JSON menu entry's. The vectors run
 // against the ELEMENT, so hand-building the class again fails naming the input.
 import { describe, expect, it } from '@gjsify/unit';
 
 import { VIEW_STACK_ICON_NAME_VECTORS } from '@gjsify/adwaita-core/conformance';
 
-import type { AdwIcon } from './elements/adw-icon.js';
-import type { AdwMenuButton } from './elements/adw-menu-button.js';
+import type { GtkImage } from './elements/gtk-image.js';
+import type { GtkMenuButton } from './elements/gtk-menu-button.js';
 
 function mount<T extends HTMLElement>(tag: string): { el: T; host: HTMLElement } {
     const host = document.createElement('div');
@@ -26,11 +26,11 @@ function extraClasses(el: HTMLElement): string[] {
     return [...el.classList].filter((c) => c !== 'adw-icon').sort();
 }
 
-export const AdwIconTest = async () => {
-    await describe('<adw-icon> mask class (normalizeIconName vectors)', async () => {
+export const GtkImageTest = async () => {
+    await describe('<gtk-image> mask class (normalizeIconName vectors)', async () => {
         for (const { icon, normalized, rule } of VIEW_STACK_ICON_NAME_VECTORS) {
             await it(`${JSON.stringify(icon)} → ${JSON.stringify(normalized)} — ${rule}`, () => {
-                const { el, host } = mount<AdwIcon>('adw-icon');
+                const { el, host } = mount<GtkImage>('gtk-image');
                 el.iconName = icon ?? null;
 
                 expect(el.resolvedIconName).toBe(normalized);
@@ -51,15 +51,15 @@ export const AdwIconTest = async () => {
         }
     });
 
-    await describe('<adw-icon> node contract', async () => {
+    await describe('<gtk-image> node contract', async () => {
         await it('is decorative — the accessible name belongs to the host control', () => {
-            const { el, host } = mount<AdwIcon>('adw-icon');
+            const { el, host } = mount<GtkImage>('gtk-image');
             expect(el.getAttribute('aria-hidden')).toBe('true');
             host.remove();
         });
 
         await it('swaps ONLY the mask class, keeping the caller position classes', () => {
-            const { el, host } = mount<AdwIcon>('adw-icon');
+            const { el, host } = mount<GtkImage>('gtk-image');
             el.classList.add('adw-drop-down-arrow', 'start');
             el.iconName = 'go-down';
             expect(extraClasses(el)).toStrictEqual(['adw-drop-down-arrow', 'adw-icon--go-down', 'start']);
@@ -75,7 +75,7 @@ export const AdwIconTest = async () => {
         });
 
         await it('sizes the box AND the mask together', () => {
-            const { el, host } = mount<AdwIcon>('adw-icon');
+            const { el, host } = mount<GtkImage>('gtk-image');
             el.iconName = 'go-next';
             // Unset: the stylesheet's 16px.
             expect(el.size).toBe(null);
@@ -97,13 +97,13 @@ export const AdwIconTest = async () => {
         });
 
         await it('paints in the INHERITED colour, not the boundary reset colour', () => {
-            // `.adw-icon` masks with `currentColor` and <adw-icon> is a custom element, so
+            // `.adw-icon` masks with `currentColor` and <gtk-image> is a custom element, so
             // the ADR-0010 `$adw-components` reset re-roots `color` on it: without
             // `color: inherit` in `_icon.scss` every icon repaints in `--window-fg-color`
             // regardless of the button it sits in.
             const { el: box, host } = mount<HTMLElement>('div');
             box.style.color = 'rgb(255, 0, 0)';
-            const icon = document.createElement('adw-icon') as AdwIcon;
+            const icon = document.createElement('gtk-image') as GtkImage;
             icon.iconName = 'go-next';
             box.appendChild(icon);
             expect(getComputedStyle(icon).backgroundColor).toBe('rgb(255, 0, 0)');
@@ -112,8 +112,8 @@ export const AdwIconTest = async () => {
     });
 
     await describe('the hand-rolled copies are gone', async () => {
-        await it('<adw-menu-button> no longer injects a stray class from its icon-name', () => {
-            const { el, host } = mount<AdwMenuButton>('adw-menu-button');
+        await it('<gtk-menu-button> no longer injects a stray class from its icon-name', () => {
+            const { el, host } = mount<GtkMenuButton>('gtk-menu-button');
             el.setAttribute('icon-name', 'a b');
             const icon = el.querySelector('.adw-icon') as HTMLElement;
             // `adw-icon--a b` would have added a second, unrelated `b` class. What it gets
@@ -122,8 +122,8 @@ export const AdwIconTest = async () => {
             host.remove();
         });
 
-        await it('<adw-menu-button> menu entries guard their icons too', () => {
-            const { el, host } = mount<AdwMenuButton>('adw-menu-button');
+        await it('<gtk-menu-button> menu entries guard their icons too', () => {
+            const { el, host } = mount<GtkMenuButton>('gtk-menu-button');
             el.menuItems = [
                 { label: 'Bad', icon: 'a b' },
                 { label: 'Good', icon: 'view-refresh-symbolic' },
@@ -142,17 +142,17 @@ export const AdwIconTest = async () => {
             host.remove();
         });
 
-        await it('every icon in the package is an <adw-icon>', () => {
+        await it('every icon in the package is a <gtk-image>', () => {
             // Asserted structurally: a page of every icon-drawing widget, and no bare span
             // carrying the base class — so a new hand-rolled `<span class="adw-icon …">`
             // fails here even when it guards its own name correctly.
             const { el: page, host } = mount<HTMLElement>('div');
             page.innerHTML = `
-                <adw-button icon="go-next" label="Next"></adw-button>
+                <gtk-button icon="go-next" label="Next"></gtk-button>
                 <adw-button-row title="Row" start-icon-name="list-add" end-icon-name="go-next"></adw-button-row>
                 <adw-status-page icon="folder" title="Empty"></adw-status-page>
                 <adw-split-button label="Save" menu='[{"label":"Save As"}]'></adw-split-button>
-                <adw-drop-down options='["a","b"]'></adw-drop-down>
+                <gtk-drop-down options='["a","b"]'></gtk-drop-down>
                 <adw-expander-row title="More" show-enable-switch></adw-expander-row>
                 <adw-avatar text="Ada" icon="avatar-default"></adw-avatar>
                 <adw-toggle-group><adw-toggle icon-name="view-list"></adw-toggle></adw-toggle-group>
@@ -160,7 +160,7 @@ export const AdwIconTest = async () => {
             const bareSpans = [...host.querySelectorAll('span.adw-icon')];
             expect(bareSpans.length).toBe(0);
             // …and the icons really are there, so the check is not vacuous.
-            expect(host.querySelectorAll('adw-icon.adw-icon').length > 5).toBe(true);
+            expect(host.querySelectorAll('gtk-image.adw-icon').length > 5).toBe(true);
             host.remove();
         });
     });

package/src/{adw-menu-button.spec.ts → gtk-menu-button.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-menu-button>'s `menu` attribute.
+// DOM-level tests for <gtk-menu-button>'s `menu` attribute.
 //
 // The element parsed the JSON itself, and the copy was weaker than the core parser
 // the split button next to it already used: it kept `id` and `icon` whatever their
@@ -11,7 +11,7 @@ import { SPLIT_BUTTON_MENU_PARSE_VECTORS } from '@gjsify/adwaita-core/conformanc
 
 /** Mount a menu button carrying `menu` as JSON, and return its rendered item labels. */
 function mountWithMenu(json: string): { el: HTMLElement; labels: string[] } {
-    const el = document.createElement('adw-menu-button');
+    const el = document.createElement('gtk-menu-button');
     el.setAttribute('menu', json);
     document.body.appendChild(el);
     const labels = Array.from(el.querySelectorAll('.adw-popover button')).map((b) => b.textContent?.trim() ?? '');
@@ -19,11 +19,11 @@ function mountWithMenu(json: string): { el: HTMLElement; labels: string[] } {
 }
 
 function unmountAll(): void {
-    for (const el of Array.from(document.querySelectorAll('adw-menu-button'))) el.remove();
+    for (const el of Array.from(document.querySelectorAll('gtk-menu-button'))) el.remove();
 }
 
-export const AdwMenuButtonTest = async () => {
-    await describe('<adw-menu-button> menu attribute', async () => {
+export const GtkMenuButtonTest = async () => {
+    await describe('<gtk-menu-button> menu attribute', async () => {
         for (const { json, entries, rule } of SPLIT_BUTTON_MENU_PARSE_VECTORS) {
             await it(`${rule}`, () => {
                 const { labels } = mountWithMenu(json ?? '');
@@ -33,7 +33,7 @@ export const AdwMenuButtonTest = async () => {
         }
 
         await it('drops a non-string id instead of leaking a number into the event', () => {
-            const el = document.createElement('adw-menu-button');
+            const el = document.createElement('gtk-menu-button');
             el.setAttribute('menu', '[{"label":"Open","id":7}]');
             document.body.appendChild(el);
 

package/src/{adw-progress-bar.spec.ts → gtk-progress-bar.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-progress-bar>.
+// DOM-level tests for <gtk-progress-bar>.
 //
 // Three things matter more than the attribute round-trips: the CLAMP is GLib's
 // (`glibClamp` from `@gjsify/adwaita-core`, not a local `Math.min/max`); a ZERO fraction
@@ -9,18 +9,18 @@
 
 import { describe, expect, it } from '@gjsify/unit';
 
-import type { AdwProgressBar } from './elements/adw-progress-bar.js';
+import type { GtkProgressBar } from './elements/gtk-progress-bar.js';
 
-function mount(): { el: AdwProgressBar; host: HTMLElement } {
+function mount(): { el: GtkProgressBar; host: HTMLElement } {
     const host = document.createElement('div');
     document.body.appendChild(host);
-    const el = document.createElement('adw-progress-bar') as AdwProgressBar;
+    const el = document.createElement('gtk-progress-bar') as GtkProgressBar;
     host.appendChild(el);
     return { el, host };
 }
 
 /** The parts, by the markup contract the stylesheet selects on. */
-function parts(bar: AdwProgressBar): { trough: HTMLElement; progress: HTMLElement; text: HTMLElement } {
+function parts(bar: GtkProgressBar): { trough: HTMLElement; progress: HTMLElement; text: HTMLElement } {
     return {
         trough: bar.querySelector('.adw-progress-bar-trough') as HTMLElement,
         progress: bar.querySelector('.adw-progress-bar-progress') as HTMLElement,
@@ -28,8 +28,8 @@ function parts(bar: AdwProgressBar): { trough: HTMLElement; progress: HTMLElemen
     };
 }
 
-export const AdwProgressBarTest = async () => {
-    await describe('<adw-progress-bar> fraction', async () => {
+export const GtkProgressBarTest = async () => {
+    await describe('<gtk-progress-bar> fraction', async () => {
         await it('starts empty, with the trough flagged so the indicator disappears', () => {
             const { el, host } = mount();
             const { trough, progress } = parts(el);
@@ -68,7 +68,7 @@ export const AdwProgressBarTest = async () => {
         });
     });
 
-    await describe('<adw-progress-bar> indeterminate', async () => {
+    await describe('<gtk-progress-bar> indeterminate', async () => {
         await it('pulse() enters the pulsing state and drops aria-valuenow', () => {
             const { el, host } = mount();
             el.fraction = 0.4;
@@ -98,7 +98,7 @@ export const AdwProgressBarTest = async () => {
         });
     });
 
-    await describe('<adw-progress-bar> text', async () => {
+    await describe('<gtk-progress-bar> text', async () => {
         await it('hides the text node until show-text, then shows the percentage', () => {
             const { el, host } = mount();
             expect(parts(el).text.hidden).toBe(true);
@@ -134,7 +134,7 @@ export const AdwProgressBarTest = async () => {
         });
     });
 
-    await describe('<adw-progress-bar> variants', async () => {
+    await describe('<gtk-progress-bar> variants', async () => {
         await it('is an 8px trough by default and a 2px hairline with osd', () => {
             // The 8px is libadwaita's (_progress-bar.scss) and the 2px is its
             // `.osd` variant — NOT the vendored web port's 6px, which
@@ -148,8 +148,8 @@ export const AdwProgressBarTest = async () => {
             // transition to be part-way through.
             const host = document.createElement('div');
             document.body.appendChild(host);
-            const plain = document.createElement('adw-progress-bar') as AdwProgressBar;
-            const osd = document.createElement('adw-progress-bar') as AdwProgressBar;
+            const plain = document.createElement('gtk-progress-bar') as GtkProgressBar;
+            const osd = document.createElement('gtk-progress-bar') as GtkProgressBar;
             osd.setAttribute('osd', '');
             host.append(plain, osd);
 

package/src/{adw-switch.spec.ts → gtk-switch.spec.ts}

@@ -1,4 +1,4 @@
-// DOM-level tests for <adw-switch>, plus the proof that both <adw-switch-row> and
+// DOM-level tests for <gtk-switch>, plus the proof that both <adw-switch-row> and
 // <adw-expander-row> still work now that the switch is lifted out of them. Two
 // invariants:
 //
@@ -12,7 +12,7 @@
 import { describe, expect, it } from '@gjsify/unit';
 
 import type { AdwExpanderRow } from './elements/adw-expander-row.js';
-import type { AdwSwitch } from './elements/adw-switch.js';
+import type { GtkSwitch } from './elements/gtk-switch.js';
 import type { AdwSwitchRow } from './elements/adw-switch-row.js';
 
 function mount<T extends HTMLElement>(tag: string): { el: T; host: HTMLElement } {
@@ -31,7 +31,7 @@ function record(el: HTMLElement, event: string): unknown[] {
 }
 
 /** The switch's own parts, by the markup contract the stylesheet selects on. */
-function parts(sw: AdwSwitch): { input: HTMLInputElement; slider: HTMLElement } {
+function parts(sw: GtkSwitch): { input: HTMLInputElement; slider: HTMLElement } {
     return {
         input: sw.querySelector('input[type="checkbox"]') as HTMLInputElement,
         slider: sw.querySelector('.adw-switch-slider') as HTMLElement,
@@ -45,10 +45,10 @@ function measure(sw: HTMLElement): { width: string; height: string; radius: stri
     return { width: box.width, height: box.height, radius: slider.borderTopLeftRadius };
 }
 
-export const AdwSwitchTest = async () => {
-    await describe('<adw-switch> state', async () => {
+export const GtkSwitchTest = async () => {
+    await describe('<gtk-switch> state', async () => {
         await it('starts off and builds the input + slider markup', () => {
-            const { el, host } = mount<AdwSwitch>('adw-switch');
+            const { el, host } = mount<GtkSwitch>('gtk-switch');
             const { input, slider } = parts(el);
             expect(el.active).toBe(false);
             expect(input).toBeTruthy();
@@ -63,7 +63,7 @@ export const AdwSwitchTest = async () => {
         await it('adopts a declarative active attribute without emitting', () => {
             const host = document.createElement('div');
             document.body.appendChild(host);
-            const el = document.createElement('adw-switch') as AdwSwitch;
+            const el = document.createElement('gtk-switch') as GtkSwitch;
             el.setAttribute('active', '');
             const events = record(el, 'notify::active');
             host.appendChild(el);
@@ -74,7 +74,7 @@ export const AdwSwitchTest = async () => {
         });
 
         await it('a programmatic set notifies, and re-setting the same value does not', () => {
-            const { el, host } = mount<AdwSwitch>('adw-switch');
+            const { el, host } = mount<GtkSwitch>('gtk-switch');
             const events = record(el, 'notify::active');
             el.active = true;
             expect(events).toStrictEqual([{ active: true }]);
@@ -87,7 +87,7 @@ export const AdwSwitchTest = async () => {
         });
 
         await it('a click on the track toggles exactly once', () => {
-            const { el, host } = mount<AdwSwitch>('adw-switch');
+            const { el, host } = mount<GtkSwitch>('gtk-switch');
             const events = record(el, 'notify::active');
             parts(el).slider.click();
             expect(el.active).toBe(true);
@@ -100,7 +100,7 @@ export const AdwSwitchTest = async () => {
             // The checkbox is 0×0, so a pointer never reaches it — but keyboard
             // activation and `input.click()` do, and the track listener must not
             // toggle a second time on the way out.
-            const { el, host } = mount<AdwSwitch>('adw-switch');
+            const { el, host } = mount<GtkSwitch>('gtk-switch');
             const events = record(el, 'notify::active');
             parts(el).input.click();
             expect(el.active).toBe(true);
@@ -109,7 +109,7 @@ export const AdwSwitchTest = async () => {
         });
 
         await it('a disabled switch does not toggle', () => {
-            const { el, host } = mount<AdwSwitch>('adw-switch');
+            const { el, host } = mount<GtkSwitch>('gtk-switch');
             el.disabled = true;
             const events = record(el, 'notify::active');
             parts(el).slider.click();
@@ -125,11 +125,11 @@ export const AdwSwitchTest = async () => {
         });
     });
 
-    await describe('<adw-switch-row> still toggles and emits through <adw-switch>', async () => {
+    await describe('<adw-switch-row> still toggles and emits through <gtk-switch>', async () => {
         await it('a programmatic row.active drives the switch and emits once', () => {
             const { el: row, host } = mount<AdwSwitchRow>('adw-switch-row');
             const events = record(row, 'notify::active');
-            const sw = row.querySelector('adw-switch') as AdwSwitch;
+            const sw = row.querySelector('gtk-switch') as GtkSwitch;
             expect(sw).toBeTruthy();
 
             row.active = true;
@@ -148,7 +148,7 @@ export const AdwSwitchTest = async () => {
             const events = record(row, 'notify::active');
             row.click();
             expect(row.active).toBe(true);
-            expect((row.querySelector('adw-switch') as AdwSwitch).active).toBe(true);
+            expect((row.querySelector('gtk-switch') as GtkSwitch).active).toBe(true);
             expect(events.length).toBe(1);
             host.remove();
         });
@@ -156,7 +156,7 @@ export const AdwSwitchTest = async () => {
         await it('a click on the switch toggles the row once, not twice', () => {
             const { el: row, host } = mount<AdwSwitchRow>('adw-switch-row');
             const events = record(row, 'notify::active');
-            const sw = row.querySelector('adw-switch') as AdwSwitch;
+            const sw = row.querySelector('gtk-switch') as GtkSwitch;
             parts(sw).slider.click();
             expect(row.active).toBe(true);
             expect(events.length).toBe(1);
@@ -169,7 +169,7 @@ export const AdwSwitchTest = async () => {
             const { el: row, host } = mount<AdwExpanderRow>('adw-expander-row');
             row.setAttribute('show-enable-switch', '');
             const events = record(row, 'notify::enable-expansion');
-            const sw = row.querySelector('adw-switch') as AdwSwitch;
+            const sw = row.querySelector('gtk-switch') as GtkSwitch;
             expect(sw.active).toBe(true); // enable-expansion defaults to true
 
             parts(sw).slider.click();
@@ -191,7 +191,7 @@ export const AdwSwitchTest = async () => {
 
             row.enableExpansion = false;
 
-            expect((row.querySelector('adw-switch') as AdwSwitch).active).toBe(false);
+            expect((row.querySelector('gtk-switch') as GtkSwitch).active).toBe(false);
             expect(enableEvents.length).toBe(0);
             // The switch's own notify never escapes the row either.
             expect(activeEvents.length).toBe(0);
@@ -201,7 +201,7 @@ export const AdwSwitchTest = async () => {
         await it('a click on the enable switch does not disclose the row', () => {
             const { el: row, host } = mount<AdwExpanderRow>('adw-expander-row');
             row.setAttribute('show-enable-switch', '');
-            const sw = row.querySelector('adw-switch') as AdwSwitch;
+            const sw = row.querySelector('gtk-switch') as GtkSwitch;
 
             parts(sw).slider.click();
             expect(row.expanded).toBe(false);
@@ -218,8 +218,8 @@ export const AdwSwitchTest = async () => {
             const { el: expander, host: expanderHost } = mount<AdwExpanderRow>('adw-expander-row');
             expander.setAttribute('show-enable-switch', '');
 
-            const rowBox = measure(row.querySelector('adw-switch') as HTMLElement);
-            const expanderBox = measure(expander.querySelector('adw-switch') as HTMLElement);
+            const rowBox = measure(row.querySelector('gtk-switch') as HTMLElement);
+            const expanderBox = measure(expander.querySelector('gtk-switch') as HTMLElement);
 
             expect(rowBox).toStrictEqual(expanderBox);
             // Pin the actual numbers too, so "both unstyled" cannot pass as