@gjsify/adwaita-web 0.62.0 → 0.63.1-next.235

package/lib/types/canvas2d/canvas2d-bridge.d.ts

@@ -1,7 +1,28 @@
-type ReadyCallback = (canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => void;
+/**
+ * The DOM types this element names, resolved through `globalThis` so the published `.d.ts`
+ * never names a `lib.dom` type directly: a consumer that loads `lib.dom` gets the real ones,
+ * one that does not still type-checks the declarations with `skipLibCheck: false`.
+ */
+export type BridgeCanvas = typeof globalThis extends {
+    HTMLCanvasElement: {
+        prototype: infer T;
+    };
+} ? T : object;
+export type BridgeContext2D = typeof globalThis extends {
+    CanvasRenderingContext2D: {
+        prototype: infer T;
+    };
+} ? T : object;
+/** `FrameRequestCallback` without `lib.dom`. */
+export type FrameCallback = (time: number) => void;
+type ElementConstructor = typeof globalThis extends {
+    HTMLElement: infer C;
+} ? C : abstract new () => object;
+declare const HostElement: ElementConstructor;
+type ReadyCallback = (canvas: BridgeCanvas, ctx: BridgeContext2D) => void;
 type ResizeCallback = (width: number, height: number) => void;
 type SignalHandler = (emitter: Canvas2DBridgeElement, ...args: unknown[]) => unknown;
-export declare class Canvas2DBridgeElement extends HTMLElement {
+export declare class Canvas2DBridgeElement extends HostElement {
     static readonly GTypeName = "GjsifyCanvas2DBridge";
     /** The signals `connect()` accepts, as `Gtk.Widget` names them. */
     static readonly signals: Record<string, string>;
@@ -28,15 +49,15 @@ export declare class Canvas2DBridgeElement extends HTMLElement {
     set content_height(v: number);
     private _write;
     /** The `<canvas>` backing this widget. Available after the first allocation. */
-    get canvas(): HTMLCanvasElement | null;
+    get canvas(): BridgeCanvas | null;
     /** The browser's own 2D context; available after the first allocation. */
-    getContext(_id: '2d'): CanvasRenderingContext2D | null;
+    getContext(_id: '2d'): BridgeContext2D | null;
     /** Runs `cb` once the 2D context is ready, synchronously if it already is. */
     onReady(cb: ReadyCallback): void;
     /** Runs `cb` on every allocation change, with the canvas dimensions already updated. */
     onResize(cb: ResizeCallback): void;
     /** The browser's own, here only so the call reads the same on every target. */
-    requestAnimationFrame(cb: FrameRequestCallback): number;
+    requestAnimationFrame(cb: FrameCallback): number;
     /** A no-op: the browser already has `requestAnimationFrame` and `performance`. */
     installGlobals(): void;
     /** `gtk_widget_queue_draw`: nothing to blit here, the canvas IS the screen. */

package/lib/types/elements/adw-application-window.d.ts

@@ -1,11 +1,21 @@
 import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
-import { AdwWindow } from './adw-window.js';
-export declare class AdwApplicationWindow extends AdwWindow {
-    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
-    application: object | null;
-    private _menubarEl;
+import type { AdwBreakpoint } from '@gjsify/adwaita-core';
+import type { AdwSlot } from '../slotted-children.js';
+import { GtkApplicationWindow } from './gtk-application-window.js';
+export declare class AdwApplicationWindow extends GtkApplicationWindow {
+    private readonly _features;
     private _model;
+    private _menubarEl;
     static get observedAttributes(): string[];
+    /** The content area — the Adw.Window:content property. */
+    get contentArea(): HTMLDivElement;
+    get content(): HTMLElement | null;
+    set content(value: HTMLElement | null);
+    get breakpoints(): readonly AdwBreakpoint[];
+    get currentBreakpoint(): AdwBreakpoint | null;
+    get dialogs(): readonly HTMLElement[];
+    get visibleDialog(): HTMLElement | null;
+    addBreakpoint(condition: string): AdwBreakpoint;
     /** Whether this window shows the application's menubar (Gtk.ApplicationWindow:show-menubar). */
     get showMenubar(): boolean;
     set showMenubar(value: boolean);
@@ -15,7 +25,13 @@ export declare class AdwApplicationWindow extends AdwWindow {
     /** The menubar strip, or null before the window is connected. */
     get menubar(): HTMLDivElement | null;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /** `Adw.ApplicationWindow` has no titlebar of its own, like `Adw.Window`. */
+    protected hasTitlebar(): boolean;
+    protected strips(): Node[];
+    protected extraSlots(): AdwSlot[];
+    protected renderFrameSize(): void;
     /**
      * The menubar, INSIDE the content area rather than beside it.
      *
@@ -23,7 +39,10 @@ export declare class AdwApplicationWindow extends AdwWindow {
      * into the content area, so a sibling would be re-homed into it one tick later. The
      * content area's own children are not watched, so prepending here is stable — and
      * it is also where the bar belongs: above the toolbar view, inside the window box.
+     * Replaces the base's observer: this bar is filled from the model, not from a slot,
+     * and observing it would re-trigger every render.
      */
-    private _buildMenubar;
-    private _renderMenubar;
+    protected _followMenubar(): void;
+    protected menubarSection(): HTMLDivElement;
+    protected _renderMenubar(): void;
 }

package/lib/types/elements/adw-bottom-sheet.d.ts

@@ -28,6 +28,9 @@ export declare class AdwBottomSheet extends HTMLElement {
     /** Whether the content is dimmed and blocked while the sheet is open (`AdwBottomSheet:modal`). */
     get modal(): boolean;
     set modal(value: boolean);
+    /** `adw_bottom_sheet_get_modal` — the NativeScript port's only door to it (ADR 0112). */
+    get_modal(): boolean;
+    set_modal(modal: boolean): void;
     /** Whether the user can dismiss the sheet (dimming / Escape / sheet.close). */
     get canClose(): boolean;
     set canClose(value: boolean);

package/lib/types/elements/adw-data-grid.d.ts

@@ -12,6 +12,10 @@ export declare class AdwDataGrid extends HTMLElement {
     set columns(value: ReadonlyArray<AdwDataGridColumn>);
     get rows(): AdwDataGridRow[];
     set rows(value: ReadonlyArray<AdwDataGridRow>);
+    get_columns(): AdwDataGridColumn[];
+    set_columns(value: ReadonlyArray<AdwDataGridColumn>): void;
+    get_rows(): AdwDataGridRow[];
+    set_rows(value: ReadonlyArray<AdwDataGridRow>): void;
     /** The optional grid caption/title (reflected to the attribute). */
     get caption(): string;
     set caption(value: string);

package/lib/types/elements/adw-window-features.d.ts

@@ -0,0 +1,39 @@
+import { AdwBreakpoint } from '@gjsify/adwaita-core';
+export declare class AdwWindowFeatures {
+    private readonly _host;
+    private _contentEl;
+    private _breakpoints;
+    private _disposeBreakpoints;
+    private _openDialogs;
+    constructor(_host: HTMLElement);
+    /** The content area, or `null` before the window is first connected. */
+    get contentArea(): HTMLDivElement | null;
+    /** The content widget — the first child of the content area. */
+    get content(): HTMLElement | null;
+    set content(value: HTMLElement | null);
+    get breakpoints(): readonly AdwBreakpoint[];
+    get currentBreakpoint(): AdwBreakpoint | null;
+    get dialogs(): readonly HTMLElement[];
+    get visibleDialog(): HTMLElement | null;
+    /**
+     * Take the content area the Gtk parent built, once. Tracks open dialogs presented inside
+     * the window: an AdwDialog raises `notify::open`, which bubbles to the host.
+     */
+    adopt(contentEl: HTMLDivElement): void;
+    /**
+     * Add a breakpoint (adw_window_add_breakpoint). The breakpoint evaluates against the
+     * window's own box and sets a `data-breakpoint` attribute when applied.
+     */
+    addBreakpoint(condition: string): AdwBreakpoint;
+    /**
+     * Bind the breakpoints to THIS box.
+     *
+     * NOT once per lifetime: `release` drops the disposer, so a window moved between
+     * parents would come back deaf — and a window is exactly the thing a client-side route
+     * change re-parents. Re-binding is cheap and idempotent, and it re-measures the new box.
+     */
+    bind(): void;
+    release(): void;
+    /** The window's size request — GTK's, not CSS's, so an absent attribute means the default. */
+    applySizeRequest(): void;
+}

package/lib/types/elements/adw-window.d.ts

@@ -1,10 +1,8 @@
-import { AdwBreakpoint } from '@gjsify/adwaita-core';
-export declare class AdwWindow extends HTMLElement {
-    private _initialized;
-    private _contentEl;
-    private _breakpoints;
-    private _disposeBreakpoints;
-    private _openDialogs;
+import type { AdwBreakpoint } from '@gjsify/adwaita-core';
+import type { AdwSlot } from '../slotted-children.js';
+import { GtkWindow } from './gtk-window.js';
+export declare class AdwWindow extends GtkWindow {
+    private readonly _features;
     static get observedAttributes(): string[];
     /** The content area — the Adw.Window:content property. */
     get contentArea(): HTMLDivElement;
@@ -19,25 +17,14 @@ export declare class AdwWindow extends HTMLElement {
     get dialogs(): readonly HTMLElement[];
     /** The currently visible dialog, or null when none is (Adw.Window:visible-dialog). */
     get visibleDialog(): HTMLElement | null;
-    /**
-     * Add a breakpoint to this window (adw_window_add_breakpoint).
-     * The breakpoint evaluates against the window's own box and sets a
-     * `data-breakpoint` attribute when applied.
-     */
+    /** Add a breakpoint to this window (adw_window_add_breakpoint). */
     addBreakpoint(condition: string): AdwBreakpoint;
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string): void;
-    private _buildOnce;
-    /**
-     * Bind the breakpoints to THIS box.
-     *
-     * NOT once per lifetime: `disconnectedCallback` releases the disposer, so a
-     * window moved between parents would come back deaf — and a window is exactly
-     * the thing a client-side route change re-parents. Re-binding is cheap and
-     * idempotent, and it re-measures the new box on the way.
-     */
-    private _bindBreakpoints;
-    /** The window's size request — GTK's, not CSS's, so an absent attribute means the default. */
-    private _applySizeRequest;
+    /** `Adw.Window` has no titlebar of its own: you pair it with a header bar. */
+    protected hasTitlebar(): boolean;
+    protected strips(): Node[];
+    protected extraSlots(): AdwSlot[];
+    protected renderFrameSize(): void;
 }

package/lib/types/elements/gtk-application-window.d.ts

@@ -1,8 +1,16 @@
+import type { ActionLike } from '@gjsify/adwaita-core';
+import type { GtkApplication } from '../application.js';
 import type { AdwSlot } from '../slotted-children.js';
 import { GtkWindow } from './gtk-window.js';
 export declare class GtkApplicationWindow extends GtkWindow {
     /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
-    application: object | null;
+    application: GtkApplication | null;
+    /** `Gio.ActionMap.add_action`: installed by `installActionMap`; the action is reachable as `win.<name>`. */
+    add_action: (action: ActionLike) => void;
+    /** `Gio.ActionMap.lookup_action`: the window's own action, or `null`. */
+    lookup_action: (name: string) => ActionLike | null;
+    /** `Gio.ActionMap.remove_action`: removing an unknown name does nothing. */
+    remove_action: (name: string) => void;
     private _menubar;
     private _menubarObserver;
     static get observedAttributes(): string[];
@@ -13,7 +21,7 @@ export declare class GtkApplicationWindow extends GtkWindow {
      * The menubar strip, created once and reused: `strips()` and `extraSlots()` both ask for
      * it, so whichever runs first builds it and the other finds it.
      */
-    private menubarSection;
+    protected menubarSection(): HTMLDivElement;
     /**
      * Titlebar, then menubar, then content — the order `update_menubar` parents the bar at
      * (:418) inside a window whose titlebar sits above its own child.
@@ -31,6 +39,6 @@ export declare class GtkApplicationWindow extends GtkWindow {
      * The observer is what makes the second half live: `bindSlottedChildren` adopts a
      * `slot="menubar"` child after connect, and a bar that appeared then must appear.
      */
-    private _followMenubar;
-    private _renderMenubar;
+    protected _followMenubar(): void;
+    protected _renderMenubar(): void;
 }

package/lib/types/elements/gtk-window.d.ts

@@ -13,6 +13,12 @@ export declare class GtkWindow extends HTMLElement {
     private _titleLabel;
     /** Watches the strip for an author's titlebar arriving after the build. */
     private _titlebarObserver;
+    /** `is-active` and `focus-widget`; `maximized` stays the attribute above. */
+    private readonly _members;
+    private readonly _closing;
+    private readonly _syncActive;
+    private readonly _onFocusIn;
+    private readonly _onFocusOut;
     static get observedAttributes(): string[];
     /**
      * `Gtk.Window:title` — the window's title.
@@ -54,6 +60,9 @@ export declare class GtkWindow extends HTMLElement {
     private _offByDefault;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    private _watchActivity;
+    private _documentIsActive;
+    private _notifyMember;
     /**
      * A `slot="titlebar"` child adopted AFTER the build has to take the strip over from the
      * server-side decoration, and `_render` is the one that notices — nothing else here runs
@@ -70,11 +79,22 @@ export declare class GtkWindow extends HTMLElement {
      * call's invariant (see `slotted-children.ts`).
      */
     protected strips(): Node[];
+    /**
+     * Whether this window has a titlebar strip at all. `Adw.Window` has none (it styles nothing
+     * itself, you pair it with a header bar), so a subclass answers `false` and neither the
+     * `titlebar` slot nor the server-side decoration is built.
+     */
+    protected hasTitlebar(): boolean;
     /** The slots a subclass adds beside `titlebar`; none by default. */
     protected extraSlots(): AdwSlot[];
     attributeChangedCallback(name: string): void;
     private _property;
     private _render;
+    /**
+     * 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.
+     */
+    protected renderFrameSize(): void;
     /**
      * The strip, in the two shapes a window can be in. With a `titlebar` child the strip
      * holds exactly that — GTK hands the whole titlebar to the bar, decorations and all. With
@@ -90,8 +110,32 @@ export declare class GtkWindow extends HTMLElement {
      * it, hide the window when `hide-on-close` is set and DESTROY it otherwise. "Destroy" is
      * the one word this port cannot mean — a page has no unref — so the default detaches the
      * frame, which is the same observable outcome for everything above it.
+     *
+     * A frame that is not in the page is not realized, so there is nothing to close; a listener
+     * that calls `close()` again is ignored, as GTK ignores it. Answers whether the window went
+     * away (hidden or detached), `false` when a listener took the request over or it was ignored.
      */
     close(): boolean;
+    /**
+     * `gtk_window_present`: show the frame. GTK also raises and focuses the toplevel, which is
+     * the window manager's to grant; a page owns no such surface, so this is only the first half.
+     */
+    present(): void;
+    /** `Gtk.Window:is-active` — see the header: the document's focus, while this frame is shown. */
+    get isActive(): boolean;
+    /** `gtk_window_is_active`. */
+    is_active(): boolean;
+    /** `Gtk.Window:focus-widget`, read live from the document. */
+    get focusWidget(): Element | null;
+    /** `gtk_window_get_focus`: the element inside the frame that has focus, or `null`. */
+    get_focus(): Element | null;
+    /**
+     * `gtk_window_set_focus`. `null` clears the focus. An element outside the frame is refused:
+     * GTK's window only focuses its own descendants.
+     */
+    set_focus(widget: Element | null): void;
+    /** `gtk_window_is_maximized`: the FRAME's state, not the browser window's. */
+    is_maximized(): boolean;
     /**
      * `gtk_window_maximize`. ASYNCHRONOUS in GTK — the GIR says so at gtkwindow.c:1044 — so
      * the property is the thing a caller watches, and this writes it directly rather than

package/lib/types/gtk-window.spec.d.ts

@@ -1 +1,7 @@
+import { type WindowSubject } from '@gjsify/adwaita-core/conformance';
+/** The `Gtk.Window` conformance subject for any window element (`gtk-window`, `adw-window`, …). */
+export declare function webWindowSubject(tag: string): {
+    subject: WindowSubject;
+    dispose: () => void;
+};
 export declare const GtkWindowTest: () => Promise<void>;

package/lib/types/pango-markup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Render Pango markup into `target`, replacing its content — the one door every
+ * `use-markup` surface in this package goes through.
+ *
+ * The `null` branch is the C fallback and is the SECURITY property: markup that does not
+ * parse is written as TEXT, so an unrecognised tag can never become an element. Callers
+ * that want markup only when a caller has asked for it read that from their own flag and
+ * pass plain text here — this function never decides whether markup is meant.
+ */
+export declare function renderPangoMarkup(target: HTMLElement, markup: string): void;

package/lib/types/pango-markup.spec.d.ts

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

package/lib/types/source-view/copy-glyph.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A recognisable copy glyph rendered inline so the opt-in `source-view` subpath needs no
+ * icon CSS. `doc` is a parameter so a caller outside the main document (a shadow root in
+ * another frame) gets nodes its own tree can adopt.
+ */
+export declare function createCopyGlyph(doc?: Document): SVGSVGElement;

package/lib/types/source-view/copy-glyph.spec.d.ts

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