@gjsify/adwaita-web 0.57.0 → 0.59.0

package/lib/types/clipboard-host.d.ts

@@ -0,0 +1,7 @@
+import type { ClipboardHost } from '@gjsify/adwaita-core';
+/**
+ * Runs `run` as the handler of a DOM `copy` event: `Clipboard.set_content` calls made meanwhile
+ * land in `data`. Returns whether any did, so the caller knows to `preventDefault()`.
+ */
+export declare function interceptCopy(data: DataTransfer | null, run: () => void): boolean;
+export declare const webClipboardHost: ClipboardHost;

package/lib/types/gdk.spec.d.ts

@@ -0,0 +1 @@
+export declare const GdkTest: () => Promise<void>;

package/lib/types/gio.spec.d.ts

@@ -0,0 +1 @@
+export declare const GioActionsTest: () => Promise<void>;

package/lib/types/gtksource/gtk-source-view.d.ts

@@ -1,5 +1,6 @@
 import { GtkAdjustment } from '@gjsify/adwaita-core';
-import type { Buffer } from '@gjsify/gtksource-core';
+import type { Buffer, Gutter } from '@gjsify/gtksource-core';
+import { STOP_EMISSION } from '@gjsify/gtksource-core';
 export declare class GtkSourceView extends HTMLElement {
     static get observedAttributes(): string[];
     private readonly session;
@@ -7,11 +8,13 @@ export declare class GtkSourceView extends HTMLElement {
     private unsubscribe;
     private built;
     private readonly gutter;
+    private readonly rightGutter;
     private readonly backdrop;
     private readonly area;
     private readonly vadj;
     private readonly hadj;
     private direction;
+    private readonly gutters;
     constructor();
     private syncAdjustments;
     private readonly onAreaScroll;
@@ -59,8 +62,8 @@ export declare class GtkSourceView extends HTMLElement {
     get_first_child(): null;
     get_next_sibling(): Element | null;
     get_parent(): Element | null;
-    /** Gutters are slice 6 (ADR 0094). */
-    get_gutter(_window_type: number): never;
+    /** `null` for any side but LEFT and RIGHT, as in GtkSourceView (ADR 0103). */
+    get_gutter(window_type: number): Gutter | null;
     get leftMargin(): number;
     set leftMargin(value: number | string);
     get rightMargin(): number;
@@ -70,7 +73,11 @@ export declare class GtkSourceView extends HTMLElement {
     get bottomMargin(): number;
     set bottomMargin(value: number | string);
     /** GJS `connect(name, cb) → id`; the handler's first argument is this view. */
-    connect(name: string, callback: (self: GtkSourceView, ...args: never[]) => void): number;
+    connect(name: string, callback: (self: GtkSourceView, ...args: never[]) => unknown): number;
+    /** `g_signal_connect_after`: runs once the plain handlers and the default of the emission have run. */
+    connect_after(name: string, callback: (self: GtkSourceView, ...args: never[]) => unknown): number;
+    /** `GObject.signal_stop_emission_by_name(view, …)`: the session owns the emissions. */
+    [STOP_EMISSION](detailedSignal: string): void;
     disconnect(id: number): void;
     /** The inner textarea, for focus and tests. */
     get textarea(): HTMLTextAreaElement;

package/lib/types/gtksource/web-editor-driver.d.ts

@@ -4,9 +4,12 @@ export interface EditorParts {
     readonly area: HTMLTextAreaElement;
     readonly backdrop: HTMLElement;
     readonly gutter: HTMLElement;
+    /** The RIGHT gutter's element, right of the text. */
+    readonly rightGutter: HTMLElement;
 }
 export declare class WebEditorDriver implements EditorDriver {
     private readonly parts;
+    readonly gutterSides: number[];
     private host;
     private text;
     private caret;
@@ -14,6 +17,7 @@ export declare class WebEditorDriver implements EditorDriver {
     private layout;
     private readonly runs;
     private scheduled;
+    private numbers;
     private listening;
     private palette;
     private attached;
@@ -24,6 +28,11 @@ export declare class WebEditorDriver implements EditorDriver {
     detach(): void;
     private onInput;
     private onSelection;
+    /**
+     * The second and third press of a multi-click: GTK asks `extend-selection` before it selects the word
+     * or line. The first press has already placed the caret, which is the location asked about.
+     */
+    private onMouseDown;
     /** `accepts-tab` is GTK's default; a textarea would move focus, so Tab inserts a tab. */
     private onKey;
     setText(text: string): void;
@@ -35,10 +44,19 @@ export declare class WebEditorDriver implements EditorDriver {
     private applyLayout;
     setPalette(palette: EditorPalette): void;
     private applyPalette;
+    invalidateGutter(): void;
     spliceLines(first: number, removed: number, inserted: number): void;
     paintLine(line: number, _lineStart: number, runs: readonly StyledRun[]): void;
     clearAll(): void;
     /** One repaint per task: a burst of `paintLine` calls from one edit costs one DOM rebuild. */
     private scheduleRender;
+    private hasColumns;
+    private hasRightColumns;
     private render;
+    /** The lines in view, or all of them where nothing is laid out (a detached element, a test DOM). */
+    private visibleLines;
+    private cellElement;
+    private columnElement;
+    /** The gutter: the renderers left of the line numbers, the numbers, the renderers right of them. */
+    private renderGutter;
 }

package/lib/types/index.d.ts

@@ -12,6 +12,7 @@ export { isIconAvailable, registerIcon } from './icon-registry.js';
 export * as Adw from './namespace/adw.js';
 export * as Gtk from './namespace/gtk.js';
 export * as Gio from './namespace/gio.js';
+export * as Gdk from './namespace/gdk.js';
 export * as GLib from './namespace/glib.js';
 export * as GObject from './namespace/gobject.js';
 export * as GtkSource from './namespace/gtksource.js';

package/lib/types/namespace/adw.d.ts

@@ -55,3 +55,4 @@ export { AdwWindow as Window } from '../elements/adw-window.js';
 export { AdwWindowTitle as WindowTitle } from '../elements/adw-window-title.js';
 export { AdwWrapBox as WrapBox } from '../elements/adw-wrap-box.js';
 export { AdwApplication as Application } from '../application.js';
+export { AdwStyleManager as StyleManager } from '../style-manager.js';

package/lib/types/namespace/gdk.d.ts

@@ -0,0 +1,7 @@
+export declare const gdk: import("@gjsify/adwaita-core").GdkClipboard;
+export declare const Display: {
+    get_default(): import("@gjsify/adwaita-core").Display;
+};
+export declare const Clipboard: typeof import("@gjsify/adwaita-core").Clipboard;
+export declare const ContentProvider: Pick<typeof import("@gjsify/adwaita-core").ContentProvider, "new_for_value">;
+export declare const ContentFormats: typeof import("@gjsify/adwaita-core").ContentFormats;

package/lib/types/namespace/gio.d.ts

@@ -1,3 +1,3 @@
 export { GioMenu as Menu, GioMenuItem as MenuItem } from '@gjsify/adwaita-core';
-export { SimpleAction, ApplicationFlags } from '@gjsify/adwaita-core';
+export { SimpleAction, SimpleActionGroup, ApplicationFlags } from '@gjsify/adwaita-core';
 export { GioApplication as Application } from '../application.js';

package/lib/types/namespace/glib.d.ts

@@ -1,3 +1,4 @@
+import { buildFilenamev, getCurrentDir, getSystemDataDirs } from '@gjsify/adwaita-core';
 export declare const PRIORITY_HIGH: number;
 export declare const PRIORITY_DEFAULT: number;
 export declare const PRIORITY_HIGH_IDLE: number;
@@ -8,3 +9,7 @@ export declare const SOURCE_CONTINUE: boolean;
 export declare const idle_add: (priority: number, run: import("@gjsify/adwaita-core").SourceFunc) => number;
 export declare const timeout_add: (priority: number, milliseconds: number, run: import("@gjsify/adwaita-core").SourceFunc) => number;
 export declare const source_remove: (sourceId: number) => boolean;
+export declare const MAXUINT32 = 4294967295;
+export declare const build_filenamev: typeof buildFilenamev;
+export declare const get_current_dir: typeof getCurrentDir;
+export declare const get_system_data_dirs: typeof getSystemDataDirs;

package/lib/types/namespace/gobject.d.ts

@@ -2,6 +2,7 @@ declare const GObjectObject: import("@gjsify/adwaita-core").GObjectConstructor;
 export { GObjectObject as Object };
 export declare const registerClass: import("@gjsify/adwaita-core").RegisterClass;
 export declare const type_ensure: (gtype: import("@gjsify/adwaita-core").GType) => void;
+export declare const signal_stop_emission_by_name: (instance: import("@gjsify/adwaita-core").GObjectInstance, detailedSignal: string) => void;
 export declare const ParamSpec: typeof import("@gjsify/adwaita-core").ParamSpec;
 export declare const ParamFlags: {
     readonly READABLE: 1;
@@ -10,6 +11,7 @@ export declare const ParamFlags: {
     readonly CONSTRUCT: 4;
     readonly CONSTRUCT_ONLY: 8;
 };
+export declare const Value: typeof import("@gjsify/adwaita-core").Value;
 export declare const TYPE_STRING: import("@gjsify/adwaita-core").GType;
 export declare const TYPE_BOOLEAN: import("@gjsify/adwaita-core").GType;
 export declare const TYPE_INT: import("@gjsify/adwaita-core").GType;

package/lib/types/namespace/gtk-enums.d.ts

@@ -20,3 +20,8 @@ export declare const TextWindowType: Readonly<{
     readonly TOP: 5;
     readonly BOTTOM: 6;
 }>;
+/** `Gtk.TextExtendSelection`: `WORD` 0 (a double click), `LINE` 1 (a triple click). */
+export declare const TextExtendSelection: Readonly<{
+    readonly WORD: 0;
+    readonly LINE: 1;
+}>;

package/lib/types/namespace/gtk.d.ts

@@ -1,5 +1,5 @@
 export { GtkAdjustment as Adjustment } from '@gjsify/adwaita-core';
-export { PolicyType, TextDirection, TextWindowType } from './gtk-enums.js';
+export { PolicyType, TextDirection, TextExtendSelection, TextWindowType } from './gtk-enums.js';
 export { GtkAboutDialog as AboutDialog } from '../elements/gtk-about-dialog.js';
 export { GtkActionBar as ActionBar } from '../elements/gtk-action-bar.js';
 export { GtkApplicationWindow as ApplicationWindow } from '../elements/gtk-application-window.js';

package/lib/types/namespace/gtksource.d.ts

@@ -1,2 +1,2 @@
-export { Buffer, Language, LanguageManager, StyleScheme, StyleSchemeManager, init } from '@gjsify/gtksource-core';
+export { Buffer, Gutter, GutterLines, GutterRenderer, GutterRendererText, Language, LanguageManager, StyleScheme, StyleSchemeManager, init, } from '@gjsify/gtksource-core';
 export { GtkSourceView as View } from '../gtksource/gtk-source-view.js';

package/lib/types/style-manager.d.ts

@@ -0,0 +1,5 @@
+import { StyleManagerBase, type StyleSource } from '@gjsify/adwaita-core';
+export declare const webStyleSource: StyleSource;
+export declare class AdwStyleManager extends StyleManagerBase {
+    static source: StyleSource;
+}

package/lib/types/style-manager.spec.d.ts

@@ -0,0 +1 @@
+export declare const StyleManagerTest: () => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-web",
-    "version": "0.57.0",
+    "version": "0.59.0",
     "description": "Adwaita/Libadwaita web components for browser targets",
     "type": "module",
     "main": "./src/index.ts",
@@ -50,17 +50,17 @@
         "@codemirror/language": "^6.12.4",
         "@codemirror/state": "^6.7.0",
         "@codemirror/view": "^6.43.4",
-        "@gjsify/adwaita-core": "^0.57.0",
-        "@gjsify/adwaita-fonts": "^0.57.0",
-        "@gjsify/adwaita-icons": "^0.57.0",
-        "@gjsify/gtksource-core": "^0.57.0",
+        "@gjsify/adwaita-core": "^0.59.0",
+        "@gjsify/adwaita-fonts": "^0.59.0",
+        "@gjsify/adwaita-icons": "^0.59.0",
+        "@gjsify/gtksource-core": "^0.59.0",
         "@lezer/highlight": "^1.2.3"
     },
     "devDependencies": {
-        "@gjsify/blueprint": "^0.57.0",
-        "@gjsify/cli": "^0.57.0",
-        "@gjsify/unit": "^0.57.0",
-        "@gjsify/vite-plugin-blueprint": "^0.57.0",
+        "@gjsify/blueprint": "^0.59.0",
+        "@gjsify/cli": "^0.59.0",
+        "@gjsify/unit": "^0.59.0",
+        "@gjsify/vite-plugin-blueprint": "^0.59.0",
         "sass": "^1.101.0",
         "typescript": "^6.0.3"
     },

package/src/application.spec.ts

@@ -58,7 +58,7 @@ export const ApplicationTest = async () => {
 
     await describe('adwaita-web: Application (ADR 0098 § 3)', async () => {
         await it('has a vector for every unlocked vfunc', () => {
-            expect(unprovenVfuncs(APPLICATION_VECTORS).length).toBe(0);
+            expect(unprovenVfuncs(APPLICATION_VECTORS, 'Gio.').length).toBe(0);
         });
         await it('Adw.Application is a Gtk.Application', () => {
             expect(Adw.Application.prototype instanceof Gtk.Application).toBe(true);

package/src/clipboard-host.ts

@@ -0,0 +1,47 @@
+// How the web door publishes `Gdk.Clipboard` content (ADR 0096 Amendment 2).
+//
+// The browser has two paths and they are not interchangeable:
+//   - inside a DOM `copy` event, `event.clipboardData.setData` is synchronous and needs no
+//     permission, but only until the event returns; the handler must then `preventDefault()` so the
+//     browser does not replace the data with the selection. This is the path of a `copy-clipboard`
+//     handler that replaces the default copy.
+//   - anywhere else, `navigator.clipboard.writeText` is asynchronous and needs a secure context and
+//     a user activation (or the permission); a refusal rejects and the core logs it.
+
+import type { ClipboardHost } from '@gjsify/adwaita-core';
+
+let copying: { data: DataTransfer; wrote: boolean } | null = null;
+
+/**
+ * Runs `run` as the handler of a DOM `copy` event: `Clipboard.set_content` calls made meanwhile
+ * land in `data`. Returns whether any did, so the caller knows to `preventDefault()`.
+ */
+export function interceptCopy(data: DataTransfer | null, run: () => void): boolean {
+    if (!data) {
+        run();
+        return false;
+    }
+    const outer = copying;
+    const frame = { data, wrote: false };
+    copying = frame;
+    try {
+        run();
+    } finally {
+        copying = outer;
+    }
+    return frame.wrote;
+}
+
+export const webClipboardHost: ClipboardHost = {
+    writeText(text) {
+        if (copying) {
+            copying.data.setData('text/plain', text);
+            copying.wrote = true;
+            return;
+        }
+        if (typeof navigator === 'undefined' || !navigator.clipboard) {
+            return Promise.reject(new Error('navigator.clipboard is not available here'));
+        }
+        return navigator.clipboard.writeText(text);
+    },
+};

package/src/gdk.spec.ts

@@ -0,0 +1,122 @@
+// The Gdk clipboard door of adwaita-web, held to the shared vectors (real GJS is their oracle, in
+// adwaita-core's `gdk.gjs.spec.ts`), plus what only a browser shows: the async Clipboard API for a
+// write outside an event, and the `copy` event's `clipboardData` inside one. Neither needs the
+// permission: `navigator.clipboard` is replaced by a recording fake, and the event carries a
+// `DataTransfer` the test reads.
+
+import {
+    driveGdkClipboardVectors,
+    GDK_CLIPBOARD_VECTORS,
+    type GdkClipboardNamespaces,
+} from '@gjsify/adwaita-core/conformance';
+import { describe, expect, it } from '@gjsify/unit';
+
+import { GtkSourceView } from './gtksource/gtk-source-view.js';
+import * as Gdk from './namespace/gdk.js';
+import * as GObject from './namespace/gobject.js';
+
+async function withClipboardApi<T>(
+    api: { writeText(text: string): Promise<void> },
+    body: () => Promise<T>,
+): Promise<T> {
+    const original = Object.getOwnPropertyDescriptor(navigator, 'clipboard');
+    Object.defineProperty(navigator, 'clipboard', { value: api, configurable: true });
+    try {
+        return await body();
+    } finally {
+        if (original) Object.defineProperty(navigator, 'clipboard', original);
+        else delete (navigator as unknown as Record<string, unknown>).clipboard;
+    }
+}
+
+const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+export const GdkTest = async () => {
+    const written: string[] = [];
+    await withClipboardApi({ writeText: async (text) => void written.push(text) }, () =>
+        driveGdkClipboardVectors(
+            {
+                name: 'adwaita-web',
+                isOracle: false,
+                display: true,
+                GObject,
+                Gdk,
+                readBack: async () => {
+                    await tick();
+                    return written[written.length - 1] ?? null;
+                },
+            } as unknown as GdkClipboardNamespaces & Parameters<typeof driveGdkClipboardVectors>[0],
+            { describe, it, expect },
+            GDK_CLIPBOARD_VECTORS,
+        ),
+    );
+
+    await describe('adwaita-web: Gdk clipboard door', async () => {
+        const mounted = () => {
+            const view = document.createElement('gtk-source-view') as GtkSourceView;
+            document.body.append(view);
+            return view;
+        };
+        const copyEvent = () =>
+            new ClipboardEvent('copy', { cancelable: true, bubbles: true, clipboardData: new DataTransfer() });
+        const setText = (text: string) => {
+            const value = new GObject.Value().init(GObject.TYPE_STRING);
+            value.set_string(text);
+            Gdk.Display.get_default().get_clipboard().set_content(Gdk.ContentProvider.new_for_value(value));
+        };
+
+        await it('writes into the copy event when a copy-clipboard handler replaces the default copy', () => {
+            const view = mounted();
+            view.buffer.text = 'ff 00';
+            view.textarea.setSelectionRange(0, 2);
+            view.connect_after('copy-clipboard', () => setText('0xFF'));
+            const event = copyEvent();
+            view.textarea.dispatchEvent(event);
+            expect(event.clipboardData?.getData('text/plain')).toBe('0xFF');
+            expect(event.defaultPrevented).toBe(true);
+            view.remove();
+        });
+
+        await it('leaves the browser copy alone when no handler wrote anything', () => {
+            const view = mounted();
+            const event = copyEvent();
+            view.textarea.dispatchEvent(event);
+            expect(event.defaultPrevented).toBe(false);
+            view.remove();
+        });
+
+        await it('publishes through navigator.clipboard outside a copy event', async () => {
+            const seen: string[] = [];
+            await withClipboardApi({ writeText: async (text) => void seen.push(text) }, async () => {
+                setText('outside');
+                await tick();
+            });
+            expect(seen[0]).toBe('outside');
+        });
+
+        await it('warns, and keeps the content, when the browser refuses the write', async () => {
+            const warnings: unknown[][] = [];
+            const original = console.warn;
+            console.warn = (...args: unknown[]) => void warnings.push(args);
+            try {
+                await withClipboardApi({ writeText: () => Promise.reject(new Error('NotAllowedError')) }, async () => {
+                    setText('refused');
+                    await tick();
+                });
+            } finally {
+                console.warn = original;
+            }
+            expect(warnings.length).toBe(1);
+            expect(Gdk.Display.get_default().get_clipboard().get_formats().to_string()).toBe(
+                'gchararray text/plain;charset=utf-8 text/plain',
+            );
+        });
+
+        await it('puts get_display and get_clipboard on a registered class', () => {
+            const Widget = GObject.registerClass({ GTypeName: 'GdkSpecWidget' }, class extends HTMLElement {});
+            const widget = new (Widget as unknown as new () => { get_display(): unknown; get_clipboard(): unknown })();
+            expect(widget.get_display()).toBe(Gdk.Display.get_default());
+            expect(widget.get_clipboard()).toBe(Gdk.Display.get_default().get_clipboard());
+        });
+    });
+};

package/src/gio.spec.ts

@@ -0,0 +1,23 @@
+// The `Gio.SimpleActionGroup` door of adwaita-web, held to the shared vectors (real GJS is their
+// oracle, in adwaita-core's `simple-action-group.gjs.spec.ts`). The door is the namespace module itself.
+
+import {
+    SIMPLE_ACTION_GROUP_VECTORS,
+    driveSimpleActionGroupVectors,
+    type GioActionsLike,
+} from '@gjsify/adwaita-core/conformance';
+import { describe, expect, it } from '@gjsify/unit';
+
+import * as Gio from './namespace/gio.js';
+
+export const GioActionsTest = async () => {
+    await driveSimpleActionGroupVectors(
+        { name: 'adwaita-web', isOracle: false, Gio: Gio as unknown as GioActionsLike },
+        { describe, it, expect },
+    );
+    await describe('adwaita-web: Gio door', async () => {
+        await it('has a vector row for every vector', () => {
+            expect(SIMPLE_ACTION_GROUP_VECTORS.length > 0).toBe(true);
+        });
+    });
+};

package/src/glib.spec.ts

@@ -2,7 +2,14 @@
 // adwaita-core's `glib-timers.gjs.spec.ts`). The door is the namespace module itself, so a member
 // that stops being exported fails here.
 
-import { GLIB_TIMER_VECTORS, driveGLibTimerVectors, type GLibTimersLike } from '@gjsify/adwaita-core/conformance';
+import {
+    GLIB_PATH_VECTORS,
+    GLIB_TIMER_VECTORS,
+    driveGLibPathVectors,
+    driveGLibTimerVectors,
+    type GLibPathsLike,
+    type GLibTimersLike,
+} from '@gjsify/adwaita-core/conformance';
 import { describe, expect, it } from '@gjsify/unit';
 
 import * as GLib from './namespace/glib.js';
@@ -26,9 +33,17 @@ export const GLibTest = async () => {
         },
         { describe, it, expect },
     );
+    await driveGLibPathVectors(
+        { name: 'adwaita-web', isOracle: false, GLib: GLib as unknown as GLibPathsLike },
+        { describe, it, expect },
+    );
     await describe('adwaita-web: GLib door', async () => {
+        await it('answers the host-bound path questions with the root and no data dirs', () => {
+            expect(GLib.get_current_dir()).toBe('/');
+            expect(GLib.get_system_data_dirs().length).toBe(0);
+        });
         await it('has a vector row for every vector', () => {
-            expect(GLIB_TIMER_VECTORS.length > 0).toBe(true);
+            expect(GLIB_TIMER_VECTORS.length > 0 && GLIB_PATH_VECTORS.length > 0).toBe(true);
         });
     });
 };

package/src/gobject-door.ts

@@ -18,9 +18,11 @@ import {
     type GObjectDoor,
     type RegisteredClass,
     type TemplateScope,
+    widgetDisplayMembers,
 } from '@gjsify/adwaita-core';
 import { propertyOf } from '@gjsify/adwaita-core/tags';
 
+import { gdk } from './namespace/gdk.js';
 import { dispatchElement, listenElement } from './gobject-elements.js';
 import { buildTemplateTree, type BuiltTemplateTree } from './shared-tree-builder.js';
 import { registerTemplateClass } from './template-classes.js';
@@ -119,6 +121,11 @@ export const webDoor: GObjectDoor = {
         Object.setPrototypeOf((klass as { prototype: object }).prototype, Constructing.prototype);
 
         const proto = (klass as { prototype: Record<string, unknown> }).prototype;
+        // `this.get_display()` / `this.get_clipboard()`, as on a realized Gtk.Widget; a class's own wins.
+        for (const [name, member] of Object.entries(widgetDisplayMembers(gdk))) {
+            if (!(name in proto))
+                Object.defineProperty(proto, name, { value: member, writable: true, configurable: true });
+        }
         const inherited = proto.connectedCallback as (() => void) | undefined;
         Object.defineProperty(proto, 'connectedCallback', {
             configurable: true,