@gjsify/adwaita-web 0.51.0 → 0.52.0

package/src/tags.spec.ts

@@ -0,0 +1,51 @@
+// `hostTagOf`/`attributeOf` (`@gjsify/adwaita-core/tags`) against `HOST_TAG_VECTORS`/
+// `ATTRIBUTE_OF_VECTORS` (`@gjsify/adwaita-core/conformance`) — a real `document.createElement`
+// and a real `Element#getAttribute`, not the function compared to itself.
+//
+// `shared-trees.spec.ts` in this same directory calls both functions too, but only to BUILD
+// the tree it renders; it checks the result against `hostTagOf`/`attributeOf` called a
+// second time on the same input, which is the same function agreeing with itself, not a
+// vector. This suite is the one that holds a call to a value nobody derived from calling it.
+import { describe, expect, it } from '@gjsify/unit';
+
+import { ATTRIBUTE_OF_VECTORS, HOST_TAG_VECTORS } from '@gjsify/adwaita-core/conformance';
+import { attributeOf, hostTagOf } from '@gjsify/adwaita-core/tags';
+
+export const AdwTagsTest = async () => {
+    await describe('hostTagOf (conformance vectors)', async () => {
+        for (const vector of HOST_TAG_VECTORS) {
+            await it(`${vector.gtype || '(empty)'} — ${vector.rule}`, () => {
+                if (vector.error !== undefined) {
+                    let caught: unknown;
+                    try {
+                        hostTagOf(vector.gtype);
+                    } catch (error) {
+                        caught = error;
+                    }
+                    expect(caught instanceof Error ? caught.message : undefined).toBe(vector.error);
+                    return;
+                }
+                const tag = hostTagOf(vector.gtype);
+                expect(tag).toBe(vector.expected);
+                // A REAL element, not just a string comparison: the browser accepts the
+                // produced tag as a custom-element-shaped name and hands one back under it.
+                expect(document.createElement(tag).tagName.toLowerCase()).toBe(vector.expected);
+            });
+        }
+    });
+
+    await describe('attributeOf (conformance vectors)', async () => {
+        for (const vector of ATTRIBUTE_OF_VECTORS) {
+            await it(`${vector.prop || '(empty)'} — ${vector.rule}`, () => {
+                expect(attributeOf(vector.prop)).toBe(vector.expected);
+                // The empty attribute name is not settable at all (`InvalidCharacterError`),
+                // so that row's DOM half stops at the string check above, like the other
+                // conformance drivers do for a row their surface cannot reach.
+                if (vector.expected === '') return;
+                const el = document.createElement('div');
+                el.setAttribute(attributeOf(vector.prop), 'x');
+                expect(el.getAttribute(vector.expected)).toBe('x');
+            });
+        }
+    });
+};

package/src/test.browser.mts

@@ -36,6 +36,8 @@ import { AdwWrapBoxTest } from './adw-wrap-box.spec.js';
 import { AdwHeaderBarTest } from './adw-header-bar.spec.js';
 import { GtkEntryTest } from './gtk-entry.spec.js';
 import { GtkMenuButtonTest } from './gtk-menu-button.spec.js';
+import { GioMenuTest } from './gio-menu.spec.js';
+import { GtkValueDoorsTest } from './gtk-value-doors.spec.js';
 import { GtkButtonTest } from './gtk-button.spec.js';
 import { AdwBannerTest } from './adw-banner.spec.js';
 import { AdwButtonContentTest } from './adw-button-content.spec.js';
@@ -44,6 +46,8 @@ import { AdwIconRegistryTest } from './icon-registry.spec.js';
 import { GtkSwitchTest } from './gtk-switch.spec.js';
 import { AdwChecksTest } from './checks.spec.js';
 import { GtkProgressBarTest } from './gtk-progress-bar.spec.js';
+import { GtkBoxTest } from './gtk-box.spec.js';
+import { GtkLabelTest } from './gtk-label.spec.js';
 import { AdwAboutDialogTest } from './adw-about-dialog.spec.js';
 import { AdwStyleClassesTest } from './style-classes.spec.js';
 import { AdwAccentTest } from './adw-accent.spec.js';
@@ -54,9 +58,19 @@ import { AdwSlottedChildrenTest } from './slotted-children.spec.js';
 import { AdwKeyboardOperableTest } from './keyboard-operable.spec.js';
 import { AdwFontsTest } from './adw-fonts.spec.js';
 import { AdwSharedTreesTest } from './shared-trees.spec.js';
+import { AdwBlueprintTreeTest } from './blueprint-tree.spec.js';
+import { AdwValueListsTest } from './value-lists.spec.js';
+import { AdwBlueprintLayoutTest } from './blueprint-layout.spec.js';
+import { AdwBlueprintMarkupTest } from './blueprint-markup.spec.js';
+import { AdwTagsTest } from './tags.spec.js';
 
 run({
     AdwSharedTreesTest,
+    AdwBlueprintTreeTest,
+    AdwValueListsTest,
+    AdwBlueprintLayoutTest,
+    AdwBlueprintMarkupTest,
+    AdwTagsTest,
     AdwKeyboardOperableTest,
     AdwConnectLifecycleTest,
     AdwEmptySectionsTest,
@@ -73,6 +87,8 @@ run({
     GtkSwitchTest,
     AdwChecksTest,
     GtkProgressBarTest,
+    GtkBoxTest,
+    GtkLabelTest,
     AdwAvatarTest,
     AdwCarouselTest,
     AdwBottomSheetTest,
@@ -97,6 +113,8 @@ run({
     AdwHeaderBarTest,
     GtkEntryTest,
     GtkMenuButtonTest,
+    GioMenuTest,
+    GtkValueDoorsTest,
     GtkButtonTest,
     AdwViewStackTest,
     AdwNavigationViewTest,

package/src/value-lists.spec.ts

@@ -0,0 +1,93 @@
+// A `.blp`'s string lists and dialog responses, built by this renderer — ADR 0072.
+//
+// Each `VALUE_LIST_VECTORS` row is a Blueprint source and what GTK builds from it, measured
+// with `Gtk.Builder`. The source goes through the real parser and projection, refused on any
+// loss as the `?shared-tree` door refuses it, then through `mountSharedTree`, and the widget
+// is read back: the options a combo row or drop-down paints, the buttons a dialog registered.
+// Before ADR 0072 the projection dropped both lists, so the same sources rendered an EMPTY
+// combo row and a dialog with no buttons, at exit 0.
+//
+// The NativeScript driver (`packages/nativescript-bridge/adwaita/src/value-lists.spec.ts`)
+// drives the same rows through its own builder.
+
+import { describe, expect, it } from '@gjsify/unit';
+
+import { parseBlueprint, projectToSharedNode } from '@gjsify/blueprint';
+import { VALUE_LIST_VECTORS } from '@gjsify/adwaita-core/conformance';
+import type { SharedTreeNode } from '@gjsify/adwaita-core/conformance';
+
+import type { AdwAlertDialog } from './elements/adw-alert-dialog.js';
+import type { AdwComboRow } from './elements/adw-combo-row.js';
+import { mountSharedTree } from './shared-tree-builder.js';
+
+/** A Blueprint object as the `?shared-tree` door hands it over, refused on any loss. */
+function blueprintTree(body: string): SharedTreeNode {
+    const { node, lost } = projectToSharedNode(
+        parseBlueprint(`using Gtk 4.0;\nusing Adw 1;\n\n${body}\n`, 'value-lists.spec.blp'),
+    );
+    if (lost.length > 0) {
+        throw new Error(`the projection dropped ${lost.map((loss) => `${loss.kind} at line ${loss.line}`).join(', ')}`);
+    }
+    return node as SharedTreeNode;
+}
+
+/** The option labels the widget paints, which is what a reader sees. */
+const paintedOptions = (el: HTMLElement) =>
+    [...el.querySelectorAll('option, .adw-drop-down-item-label')].map((node) => node.textContent);
+
+/** Mount, run, and unmount even when the body throws. */
+function mounted(tree: SharedTreeNode, body: (root: HTMLElement) => void): void {
+    const { root, unmount } = mountSharedTree(tree);
+    try {
+        body(root);
+    } finally {
+        unmount();
+    }
+}
+
+export const AdwValueListsTest = async () => {
+    await describe('adwaita-web: VALUE_LIST_VECTORS through a .blp', async () => {
+        for (const vector of VALUE_LIST_VECTORS) {
+            await it(vector.rule, () => {
+                mounted(blueprintTree(vector.blueprint), (root) => {
+                    if (vector.strings !== undefined) {
+                        const model = (root as unknown as Pick<AdwComboRow, 'model'>).model;
+                        expect(JSON.stringify(model.map((option) => option.label))).toBe(
+                            JSON.stringify(vector.strings),
+                        );
+                        expect(JSON.stringify(paintedOptions(root))).toBe(JSON.stringify(vector.strings));
+                        // Consumed as data, as GtkBuilder leaves no list model in the widget tree.
+                        expect(root.querySelector('gtk-string-list')).toBe(null);
+                    }
+                    if (vector.responses !== undefined) {
+                        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),
+                        }));
+                        expect(JSON.stringify(read)).toBe(JSON.stringify(vector.responses));
+                        // The buttons the dialog paints, in the order the source wrote them.
+                        const painted = [...root.querySelectorAll('.adw-alert-dialog-response')].map(
+                            (button) => button.textContent,
+                        );
+                        expect(JSON.stringify(painted)).toBe(JSON.stringify(vector.responses.map((r) => r.label)));
+                    }
+                });
+            });
+        }
+    });
+
+    await describe('adwaita-web: an extension no element takes is refused', async () => {
+        await it('a string list at a slot the parent has no destination for', () => {
+            const tree = blueprintTree('Gtk.Box { Gtk.StringList { strings [ "a" ] } }');
+            expect(() => mountSharedTree(tree)).toThrow();
+        });
+
+        await it('responses on an element that is not a dialog', () => {
+            const tree: SharedTreeNode = { tag: 'GtkBox', extensions: { responses: [{ id: 'ok', label: 'OK' }] } };
+            expect(() => mountSharedTree(tree)).toThrow();
+        });
+    });
+};

package/lib/types/source-view/hex.d.ts

@@ -1,21 +0,0 @@
-/** Bytes represented per visual line in the hex monitor / hexdump gutter. */
-export declare const HEX_ADDRESS_STRIDE = 16;
-/**
- * Format a 1-based CodeMirror line number as a 4-digit uppercase hex address, the way the
- * native GtkSourceView hex gutter renders monitor/hexdump rows: each row advances the
- * address by `stride` bytes from `start` (the base address of the first row, e.g. 0x0600
- * for a 6502 program). `lineNo` is 1-based, per CodeMirror's `formatNumber` contract.
- */
-export declare function formatHexAddress(lineNo: number, start: number, stride?: number): string;
-/**
- * Format a 1-based CodeMirror line number for the normal (decimal) gutter, offset so
- * `start` is the value shown on the first line — the web twin of the native renderer's
- * `line + startValue`.
- */
-export declare function formatLineNumber(lineNo: number, start?: number): string;
-/**
- * Strip every whitespace character from `text` — the copy-without-spaces
- * transform the native hex monitor applies so a copied address/byte run pastes
- * as a compact hex string. Mirrors `text.replace(/\s/g, '')` in the GTK widget.
- */
-export declare function stripWhitespace(text: string): string;

package/src/source-view/hex.ts

@@ -1,37 +0,0 @@
-// Pure, framework-free helpers for <adw-source-view>. They carry no CodeMirror
-// or DOM dependency so they stay unit-testable on any runtime and drive the
-// gutter formatter + the hex copy-without-spaces behaviour.
-// Reference: packages/app-gnome/src/gutter-renderer-line-numbers.ts (native parity)
-// Reference: packages/app-gnome/src/widgets/source-view.ts onCopyHexClipboard()
-
-/** Bytes represented per visual line in the hex monitor / hexdump gutter. */
-export const HEX_ADDRESS_STRIDE = 16;
-
-/**
- * Format a 1-based CodeMirror line number as a 4-digit uppercase hex address, the way the
- * native GtkSourceView hex gutter renders monitor/hexdump rows: each row advances the
- * address by `stride` bytes from `start` (the base address of the first row, e.g. 0x0600
- * for a 6502 program). `lineNo` is 1-based, per CodeMirror's `formatNumber` contract.
- */
-export function formatHexAddress(lineNo: number, start: number, stride: number = HEX_ADDRESS_STRIDE): string {
-    const address = start + (lineNo - 1) * stride;
-    return address.toString(16).padStart(4, '0').toUpperCase();
-}
-
-/**
- * Format a 1-based CodeMirror line number for the normal (decimal) gutter, offset so
- * `start` is the value shown on the first line — the web twin of the native renderer's
- * `line + startValue`.
- */
-export function formatLineNumber(lineNo: number, start: number = 1): string {
-    return String(lineNo - 1 + start);
-}
-
-/**
- * Strip every whitespace character from `text` — the copy-without-spaces
- * transform the native hex monitor applies so a copied address/byte run pastes
- * as a compact hex string. Mirrors `text.replace(/\s/g, '')` in the GTK widget.
- */
-export function stripWhitespace(text: string): string {
-    return text.replace(/\s/g, '');
-}