@gjsify/adwaita-web 0.64.1-next.240 → 0.64.1-next.243

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

@@ -37,6 +37,24 @@ export declare class Canvas2DBridgeElement extends HostElement {
     private _height;
     private _drawFrame;
     static get observedAttributes(): string[];
+    /**
+     * `Gtk.Widget:focusable`, whether the widget can hold the keyboard focus. `Gtk.DrawingArea`
+     * leaves it FALSE, so it is read by PRESENCE; a blueprint's `focusable: true` writes it.
+     */
+    get focusable(): boolean;
+    set focusable(v: boolean);
+    /** `Gtk.Widget:can-focus`, TRUE by default, so it is read by VALUE. */
+    get canFocus(): boolean;
+    set canFocus(v: boolean);
+    get can_focus(): boolean;
+    set can_focus(v: boolean);
+    /**
+     * `gtk_widget_grab_focus`: moves the keyboard focus here and says whether it landed.
+     * FALSE when the widget is not focusable or cannot focus, as in GTK.
+     */
+    grab_focus(): boolean;
+    grabFocus(): boolean;
+    private _syncFocus;
     /** `Gtk.DrawingArea:content-width`, the minimum and natural width. Defaults to 0. */
     get contentWidth(): number;
     set contentWidth(v: number);

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

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

package/lib/types/elements/adw-action-row.d.ts

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class AdwActionRow extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _titleEl;
     private _subtitleEl;
     private _suffixEl;

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

@@ -1,4 +1,5 @@
 import type { BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetOpenOutcome, BottomSheetOpenSource } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 /** The persistent content. Child of <adw-bottom-sheet>; consumed at connect time. */
 export declare class AdwBottomSheetContent extends HTMLElement {
 }
@@ -9,6 +10,8 @@ export declare class AdwBottomSheetSheet extends HTMLElement {
 export declare class AdwBottomSheetBottomBar extends HTMLElement {
 }
 export declare class AdwBottomSheet extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _initialized;
     private _contentEl;
     private _dimmingEl;

package/lib/types/elements/adw-navigation-view.d.ts

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 /** A single navigation page. Children of <adw-navigation-view>. */
 export declare class AdwNavigationPage extends HTMLElement {
     /** Set while the owning view writes an attribute back, so the sync cannot recurse. */
@@ -15,6 +16,8 @@ export declare class AdwNavigationPage extends HTMLElement {
     revertAttribute(name: string, value: string | null): void;
 }
 export declare class AdwNavigationView extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _pagesEl;
     private readonly _backButtons;
     private _initialized;
@@ -28,6 +31,8 @@ export declare class AdwNavigationView extends HTMLElement {
     set popOnEscape(value: boolean);
     get visiblePage(): AdwNavigationPage | null;
     get visiblePageTag(): string | null;
+    /** `adw_navigation_view_get_visible_page_tag`. */
+    get_visible_page_tag(): string | null;
     get depth(): number;
     /** The navigation stack, bottom-first (Adw.NavigationView:navigation-stack). */
     get navigationStack(): readonly AdwNavigationPage[];
@@ -64,6 +69,8 @@ export declare class AdwNavigationView extends HTMLElement {
      * destroyed when it is popped.
      */
     push(pageOrTag: AdwNavigationPage | string): boolean;
+    /** `adw_navigation_view_push_by_tag`, under the name a GJS caller uses. */
+    push_by_tag(tag: string): boolean;
     /** Push the page carrying `tag` (mirrors AdwNavigationView.push_by_tag). */
     pushByTag(tag: string): boolean;
     /**

package/lib/types/elements/adw-switch-row.d.ts

@@ -1,5 +1,8 @@
+import type { DispatchedSignals } from '../signals.js';
 import './gtk-switch.js';
 export declare class AdwSwitchRow extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _switchEl;
     private _prefixEl;
     /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */

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

@@ -34,6 +34,11 @@ export declare class AdwWindowFeatures {
      */
     bind(): void;
     release(): void;
-    /** The window's size request — GTK's, not CSS's, so an absent attribute means the default. */
+    /**
+     * The window's size. `Adw.Window` defaults to a 360×200 MINIMUM (a size request, not the
+     * size; `width-request`/`height-request` override it). `default-width/height` is only
+     * a default: an authored size is the box, and an absent one leaves the box to the
+     * stylesheet, which fills the viewport — a page has no window manager to pick a size.
+     */
     applySizeRequest(): void;
 }

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

@@ -1,5 +1,6 @@
 import type { ActionLike } from '@gjsify/adwaita-core';
 import type { GtkApplication } from '../application.js';
+import type { DispatchedSignals } from '../signals.js';
 import type { AdwSlot } from '../slotted-children.js';
 import { GtkWindow } from './gtk-window.js';
 export declare class GtkApplicationWindow extends GtkWindow {
@@ -13,6 +14,7 @@ export declare class GtkApplicationWindow extends GtkWindow {
     remove_action: (name: string) => void;
     private _menubar;
     private _menubarObserver;
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): string[];
     /** `Gtk.ApplicationWindow:show-menubar` — whether the window shows a menubar of its own. */
     get showMenubar(): boolean;

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

@@ -10,15 +10,22 @@ export declare const MASK_CLASS_PREFIX = "adw-icon--";
  * returns for a name it cannot find.
  */
 export declare const MISSING_ICON_NAME = "image-missing";
+/**
+ * The modifier a colour icon carries. Deliberately NOT under {@link MASK_CLASS_PREFIX}: the
+ * stale-class sweep below and `.adw-icon:not([class*='adw-icon--'])` both read that prefix
+ * as "a mask is applied", and a colour icon has none.
+ */
+export declare const COLOR_ICON_CLASS = "adw-icon-color";
 export declare class GtkImage extends HTMLElement {
     static get observedAttributes(): string[];
     /** The declared symbolic name, `-symbolic` suffix optional. */
     get iconName(): string;
     set iconName(value: string | null);
     /**
-     * The name that actually reached the mask class — `''` when the icon-name is
-     * absent, empty, or not usable as one CSS token. Consumers that need to know
-     * whether the DECLARED name is drawable ask this, not the raw attribute.
+     * The name the SYMBOLIC lookup works with — `''` when the icon-name is absent, empty,
+     * or not usable as one CSS token. A registered colour icon can still draw for a name
+     * that answers `''` here (`org.gnome.Builder`); whether a name draws anything but
+     * `image-missing` is `isIconAvailable`'s question.
      *
      * `''` does NOT mean the box draws nothing: an unusable name that was given still
      * draws {@link MISSING_ICON_NAME}. Whether an icon was ASKED FOR is the raw
@@ -28,7 +35,9 @@ export declare class GtkImage extends HTMLElement {
     /** The rendered edge length in px, or `null` when the stylesheet decides. */
     get size(): number | null;
     set size(value: number | null);
+    private _unsubscribe;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
     private _render;
 }

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

@@ -76,6 +76,16 @@ export declare class GtkScrolledWindow extends HTMLElement {
      */
     hscrollbar(): HTMLElement | null;
     vscrollbar(): HTMLElement | null;
+    /** `Gtk.ScrolledWindow:child` — the widget inside the viewport, or the one waiting to be adopted. */
+    get child(): Element | null;
+    set child(value: Element | null);
+    get_child(): Element | null;
+    /**
+     * `gtk_scrolled_window_set_child`: replace the child, which sits in the viewport. Before the
+     * first connect there is no viewport yet, so the child waits in the light DOM where
+     * `connectedCallback` adopts it the way it adopts a declared one.
+     */
+    set_child(child: Element | null): void;
     /** The `<gtk-viewport>` the child sits in — the one GTK's `set_child` builds for itself. */
     get viewport(): GtkViewport;
     connectedCallback(): void;

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

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 import { type AdwSlot } from '../slotted-children.js';
 import './gtk-window-controls.js';
 export declare class GtkWindow extends HTMLElement {
@@ -19,6 +20,25 @@ export declare class GtkWindow extends HTMLElement {
     private readonly _syncActive;
     private readonly _onFocusIn;
     private readonly _onFocusOut;
+    /**
+     * The GObject door (ADR 0096 § 3): `connect` / `disconnect` / `emit` / `notify` / `get_property` /
+     * `set_property` over these events, the same ones every element declares in `static signals`.
+     * A `close-request` handler that returns true is `preventDefault()`.
+     */
+    static readonly signals: DispatchedSignals;
+    /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
+    connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
+    /** `GObject.Object.disconnect`: throws for an id that is not connected. */
+    disconnect: (id: number) => void;
+    /** `GObject.Object.emit`; `close-request` is refused, call `close()`. */
+    emit: (signal: string, ...args: unknown[]) => void;
+    /** `GObject.Object.notify`. */
+    notify: (name: string) => void;
+    /** `GObject.Object.get_property`, by GTK's dashed name. */
+    get_property: (name: string) => unknown;
+    /** `GObject.Object.set_property`; a read-only property throws. */
+    set_property: (name: string, value: unknown) => void;
+    constructor();
     static get observedAttributes(): string[];
     /**
      * `Gtk.Window:title` — the window's title.
@@ -121,12 +141,18 @@ export declare class GtkWindow extends HTMLElement {
      * 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. */
+    /**
+     * `Gtk.Window:is-active` — see the header: the document's focus, while this frame is shown.
+     * A PROPERTY, as in GJS and `@girs/gtk-4.0`: GTK 4 has no `gtk_window_is_active`, so
+     * `window.is_active` is the value and `window.is_active()` does not exist.
+     */
     get isActive(): boolean;
-    /** `gtk_window_is_active`. */
-    is_active(): boolean;
+    get is_active(): boolean;
     /** `Gtk.Window:focus-widget`, read live from the document. */
     get focusWidget(): Element | null;
+    /** `Gtk.Window:focus-widget` under its GJS spelling; writing it is `set_focus`. */
+    get focus_widget(): Element | null;
+    set focus_widget(widget: Element | null);
     /** `gtk_window_get_focus`: the element inside the frame that has focus, or `null`. */
     get_focus(): Element | null;
     /**

package/lib/types/gobject-elements.d.ts

@@ -6,6 +6,13 @@ export declare function ensureNotifying(el: HTMLElement, property: string): void
 /** Calls `handler(el, ...args)` for `signal`; returns the disconnect. */
 export declare function listenElement(el: HTMLElement, signal: string, handler: Handler): () => void;
 export declare function dispatchElement(el: HTMLElement, signal: string, args: readonly unknown[]): void;
+/**
+ * `Gtk.Widget:sensitive` for an element that has no member of that name. The DOM spells it
+ * `disabled` on a form control and `aria-disabled` on anything else (`adw-action-row.ts` reads
+ * both), so the accessor writes the spelling the element understands. An element that already
+ * declares `sensitive` (`<adw-toggle-group>`) keeps its own.
+ */
+export declare function installSensitive(el: HTMLElement): void;
 /** Gives `el` the instance API of a registered class, over the events it declares. */
 export declare function installElementApi(el: HTMLElement): void;
 /**

package/lib/types/icon-registry.d.ts

@@ -18,7 +18,9 @@
  */
 export declare function registerIcon(name: string, svg: string): void;
 /**
- * Whether `name` has a glyph — compiled into the stylesheet, or registered at runtime.
+ * Whether `name` draws something other than `image-missing` — a symbolic glyph compiled into
+ * the stylesheet or registered at runtime, or a colour icon from `registerColorIcon`. The
+ * name is looked up exactly as `<gtk-image icon-name>` looks it up (`icon-theme.ts`).
  *
  * Reads the live cascade rather than a generated list, so it answers for a glyph that
  * arrived by any route, including a consumer's own `--icon-<name>` declaration. It is

package/lib/types/icon-theme.d.ts

@@ -0,0 +1,53 @@
+/** What one icon name resolves to, in the order GTK's theme would try it. */
+export type IconLookup = 
+/** A registered full-colour image, drawn as-is. `url` is ready for `url("…")`. */
+{
+    kind: 'color';
+    name: string;
+    url: string;
+}
+/** A symbolic glyph, drawn through the `.adw-icon--<name>` mask. `name` is normalized. */
+ | {
+    kind: 'symbolic';
+    name: string;
+}
+/** Nothing in the theme answers this name — draw `image-missing`. */
+ | {
+    kind: 'missing';
+};
+/** Subscribe to theme changes. Returns the unsubscribe function. */
+export declare function onIconThemeChanged(listener: () => void): () => void;
+/** Run every subscriber — after any registration that can change a lookup's answer. */
+export declare function notifyIconThemeChanged(): void;
+/**
+ * Resolve `iconName` as `gtk_icon_theme_lookup_by_gicon` would for a `GtkImage`. `null` when
+ * no name was given — the state where GTK draws nothing, not `image-missing`.
+ *
+ * When no colour icon is registered for the name, a symbolic request is returned WITHOUT
+ * checking the cascade: the mask class falls back to `image-missing` through CSS by itself
+ * and corrects itself when a later `registerIcon` lands, which is how `<gtk-image>` behaved
+ * before this module. The cascade is read only to choose between a colour entry and a
+ * symbolic glyph.
+ */
+export declare function lookupIcon(iconName: string | null | undefined): IconLookup | null;
+/**
+ * Whether `iconName` resolves to something other than `image-missing` — a registered colour
+ * icon, or a symbolic glyph compiled into the stylesheet or registered at runtime.
+ */
+export declare function iconResolves(iconName: string): boolean;
+/**
+ * Register a FULL-COLOUR icon under `name` — what an application ships in
+ * `hicolor/scalable/apps/<app-id>.svg` and GTK finds through its icon theme. Every
+ * `<gtk-image>` asking for the name draws the image unrecoloured, the way `AdwAboutDialog`'s
+ * `application-icon` does on GNOME.
+ *
+ * `name` is the EXACT icon name, reverse-DNS application IDs included. A name with a
+ * `-symbolic` suffix THROWS: that is the other half of the theme, and {@link registerIcon}
+ * is its door. `source` is SVG source, or a URL (resolved against the document) to any
+ * image the browser can draw.
+ *
+ * Re-registering a name replaces the image, and every mounted `<gtk-image>` redraws.
+ *
+ * CLIENT-SIDE ONLY, like `registerIcon`: it reads `document`.
+ */
+export declare function registerColorIcon(name: string, source: string): void;

package/lib/types/icon-theme.spec.d.ts

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

package/lib/types/index.d.ts

@@ -9,6 +9,7 @@ export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
 export type { MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
 export { registerTemplateClass } from './template-classes.js';
 export { isIconAvailable, registerIcon } from './icon-registry.js';
+export { registerColorIcon } from './icon-theme.js';
 export * as Adw from './namespace/adw.js';
 export * as Gtk from './namespace/gtk.js';
 export * as Gio from './namespace/gio.js';