@gjsify/adwaita-web 0.64.1-next.241 → 0.64.1-next.244

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

@@ -30,6 +30,7 @@ export declare class AdwActionRow extends HTMLElement {
     set activatableWidget(widget: HTMLElement | null);
     /** Whether a click activates this row — `GtkListBoxRow:activatable`. */
     get activatable(): boolean;
+    constructor();
     connectedCallback(): void;
     /** Copy the declarative attributes into the headless state. */
     private _adoptAttributes;

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

@@ -71,6 +71,7 @@ export declare class AdwBottomSheet extends HTMLElement {
      * a swipe, and the drag handle never closes anything (`resolveBottomSheetClose`).
      */
     requestClose(source: BottomSheetCloseSource): BottomSheetCloseOutcome;
+    constructor();
     connectedCallback(): void;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     /** The programmatic open/close — `AdwBottomSheet:open`, ungated by `can-close`. */

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

@@ -41,6 +41,7 @@ export declare class AdwNavigationView extends HTMLElement {
     get canGoBack(): boolean;
     /** The back button's tooltip — the previous page's title, or null when there is no button. */
     get backButtonTooltip(): string | null;
+    constructor();
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
     /**

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

@@ -17,6 +17,7 @@ export declare class AdwSwitchRow extends HTMLElement {
     get prefixSection(): HTMLDivElement;
     get active(): boolean;
     set active(value: boolean);
+    constructor();
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
     /**

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/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';

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

@@ -72,6 +72,7 @@ export { GtkToggleButton as ToggleButton } from '../elements/gtk-toggle-button.j
 export { GtkTreeExpander as TreeExpander } from '../elements/gtk-tree-expander.js';
 export { GtkVideo as Video } from '../elements/gtk-video.js';
 export { GtkWindow as Window } from '../elements/gtk-window.js';
+export type { WindowCommon } from '@gjsify/adwaita-core';
 export { GtkWindowControls as WindowControls } from '../elements/gtk-window-controls.js';
 export { GtkViewport as Viewport } from '../elements/gtk-viewport.js';
 export { GtkWindowHandle as WindowHandle } from '../elements/gtk-window-handle.js';