@gjsify/adwaita-web 0.55.0 → 0.57.0

package/lib/types/adw-status-page.spec.d.ts

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

package/lib/types/application.d.ts

@@ -0,0 +1,24 @@
+import { GioApplicationBase, type AdwMenuItem, type AdwMenuActions, type AdwMenuModel, type ApplicationHost } from '@gjsify/adwaita-core';
+export declare const webHost: ApplicationHost;
+/** An element's parent for action resolution; a popover is rooted at the widget that owns it. */
+export declare function parentOfElement(node: object): object | null;
+/** What a `Gtk.Actionable` does on activation: the action `prefix.name` found from `widget`. */
+export declare function activateWidgetAction(widget: Element, fullName: string, parameter?: unknown): boolean;
+/** What the items of `model` read from the actions registered above `el` (ADR 0097 § 3). */
+export declare function menuActionsOfElement(el: Element, model: AdwMenuModel): AdwMenuActions;
+/** What choosing `item` in a menu owned by `el` does: the action it names fires. */
+export declare function activateElementMenuItem(el: Element, item: AdwMenuItem): boolean;
+export declare class GioApplication extends GioApplicationBase {
+    static host: ApplicationHost;
+}
+declare const GtkApplication_base: typeof GioApplication & import("@gjsify/adwaita-core").GtkApplicationConstructor;
+export declare class GtkApplication extends GtkApplication_base {
+}
+export declare class AdwApplication extends GtkApplication {
+}
+/**
+ * `Gtk.Window:application` and the window's `Gio.ActionMap` (`win.` actions) on an element class.
+ * Setting the property is `add_window`, as on GTK; setting it to `null` is `remove_window`.
+ */
+export declare function defineWindowApplication(proto: object): void;
+export {};

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

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

package/lib/types/attributes.d.ts

@@ -0,0 +1,19 @@
+import { VALUE_BASED_BOOLEAN_ATTRS } from '@gjsify/adwaita-core/tags';
+/** Re-export for consumers that need the list (e.g. `shared-tree-builder.ts`). */
+export { VALUE_BASED_BOOLEAN_ATTRS };
+/**
+ * Whether an attribute spells a boolean property, defaulting to `whenAbsent`.
+ *
+ * Absent is the property's default; present, the literal `"false"` is FALSE and anything
+ * else is TRUE.
+ */
+export declare function booleanAttribute(value: string | null, whenAbsent: boolean): boolean;
+/**
+ * Write a value-based boolean attribute (GTK property defaulting to TRUE).
+ *
+ * `true`  → sets `attr="true"` (present, not "false", reads as true)
+ * `false` → sets `attr="false"` (present, reads as false)
+ * This avoids `toggleAttribute` which removes the attribute for `false`,
+ * causing value-based readers to fall back to the default (true).
+ */
+export declare function writeBooleanAttribute(el: HTMLElement, attr: string, value: boolean): void;

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

@@ -3,6 +3,8 @@ export declare class AdwActionRow extends HTMLElement {
     private _subtitleEl;
     private _suffixEl;
     private _prefixEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     /** The headless labels + activatable-widget coupling (ADR 0004). */
     private readonly _state;
     /** Watches the activatable widget's `disabled`/`aria-disabled` — the live binding. */
@@ -46,4 +48,6 @@ export declare class AdwActionRow extends HTMLElement {
     /** Reflect the state's `activatable` back onto the attribute + class. */
     private _syncActivatable;
     private _render;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

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

@@ -1,6 +1,8 @@
 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;
     private _model;
     static get observedAttributes(): string[];

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

@@ -2,6 +2,8 @@ import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
 export declare class AdwComboRow extends HTMLElement {
     private _select;
     private _valueEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
@@ -78,4 +80,6 @@ export declare class AdwComboRow extends HTMLElement {
      */
     private _syncChooser;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

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

@@ -49,6 +49,12 @@ export declare class AdwEntryRow extends HTMLElement {
     get editing(): boolean;
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * The parts `tooltip-text` lands on: the two slots and the editable area — NOT the
+     * apply button or the indicator, which carry tooltips of their own that the consumer
+     * reads for what they are.
+     */
+    private _tooltipParts;
     /**
      * Add a widget after the editable area — `adw_entry_row_add_suffix`, which APPENDS
      * into a box, so several suffixes coexist and the password row's own peek toggle

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

@@ -32,4 +32,6 @@ export declare class AdwExpanderRow extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
     private _render;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

package/lib/types/elements/adw-header-bar.d.ts

@@ -18,6 +18,12 @@ export declare class AdwHeaderBar extends HTMLElement {
      * bare `Adw.HeaderBar {}` in a `.blp` page shows "Mailboxes" with no title of its own.
      */
     private _page;
+    /**
+     * The window the bar sits in: `update_title`'s last stop before the application name
+     * (`gtk_window_get_title` of the root), so a bar with no title of its own, under no titled
+     * page, shows the window's.
+     */
+    private _window;
     private _pageObserver;
     static get observedAttributes(): string[];
     /** The start (left) section container — append buttons/widgets here. */

package/lib/types/elements/adw-overlay-split-view.d.ts

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class AdwOverlaySplitView extends HTMLElement {
+    /** The GTK signals this element dispatches, which is what a `.blp` `bind` of `show-sidebar` follows. */
+    static readonly signals: DispatchedSignals;
     private _initialized;
     private _sidebarEl;
     private _contentEl;
@@ -16,6 +19,8 @@ export declare class AdwOverlaySplitView extends HTMLElement {
      * `show-sidebar` + `pin-sidebar` mean together, held to `OVERLAY_COLLAPSE_VECTORS`.
      */
     private _state;
+    /** The `show-sidebar` the last `notify::show-sidebar` (or the first read) settled on. */
+    private _notifiedShowSidebar;
     /** Re-entrancy guard for {@link _reflectShowSidebar}. */
     private _reflecting;
     /** The view's own width in CSS px — the size the sidebar fraction is OF. */
@@ -66,6 +71,14 @@ export declare class AdwOverlaySplitView extends HTMLElement {
      * loop rather than a render.
      */
     private _reflectShowSidebar;
+    /**
+     * `notify::show-sidebar`, raised on the EFFECTIVE value — the state's, after an auto-hide on
+     * collapse — and only when it changed, the way GObject notifies. Every path that moves it
+     * (the attribute, the property, a breakpoint, a gesture) ends in {@link _reflectShowSidebar},
+     * so this is the one place it is raised. The first read only records the baseline: a bind
+     * reads the current value itself.
+     */
+    private _notifyShowSidebar;
     private _syncBreakpoint;
     openSidebar(): void;
     hideSidebar(): void;

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

@@ -3,9 +3,10 @@ import { type AdwSidebarItemSpec, type AdwSidebarSectionSpec, type SidebarItemFi
 export declare class AdwSidebarItem extends HTMLElement {
     static get observedAttributes(): string[];
     /**
-     * `AdwSidebarItem:enabled`, under the GIR name — the `disabled` attribute inverted. The
-     * property is what lets an authored `enabled: false` reach this item through the
+     * `AdwSidebarItem:enabled`, under the GIR name — the `disabled` attribute inverted.
+     * The property is what lets an authored `enabled: false` reach this item through the
      * shared-tree builder, which writes a `false` through the element's own property.
+     * Reads both the presence-based `disabled` and value-based `enabled` attributes.
      */
     get enabled(): boolean;
     set enabled(value: boolean);

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

@@ -1,6 +1,10 @@
 import type { AdwAdjustment, AdwAdjustmentInput } from '@gjsify/adwaita-core';
 export declare class AdwSpinRow extends HTMLElement {
     private _input;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
+    /** The −/input/+ box — the other half of the row's surface. */
+    private _controlEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless adjustment: the range, the clamp and the two signals (ADR 0004, ADR 0047). */
@@ -21,6 +25,8 @@ export declare class AdwSpinRow extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
     /** A stepper press — the interactive path, so it emits `notify::value`. */
     private _adjust;
     private _emitChange;

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

@@ -2,6 +2,8 @@ import './gtk-switch.js';
 export declare class AdwSwitchRow extends HTMLElement {
     private _switchEl;
     private _prefixEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless active flag + its notify rule (ADR 0004). */
@@ -21,4 +23,6 @@ export declare class AdwSwitchRow extends HTMLElement {
      */
     private _apply;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

package/lib/types/elements/adw-toggle-group.d.ts

@@ -1,6 +1,7 @@
 /** A single toggle. Children of <adw-toggle-group>; consumed at connect time. */
 export declare class AdwToggle extends HTMLElement {
     static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
 }
 export declare class AdwToggleGroup extends HTMLElement {
     private _innerEl;
@@ -12,7 +13,21 @@ export declare class AdwToggleGroup extends HTMLElement {
     private _stateAttr;
     /** Each toggle's `name`, in order — what `active-name` resolves against. */
     private _names;
+    /** `AdwToggle:enabled` per rendered button, in order — `add_toggle` spends this at add time. */
+    private _enabled;
+    /** The authored <adw-toggle> elements, kept to observe live `enabled` changes. */
+    private _toggles;
     static get observedAttributes(): string[];
+    /**
+     * `GtkWidget:sensitive` — whether the whole group is insensitive.
+     *
+     * TRUE unless the attribute says `false`, because the property defaults to TRUE and a
+     * boolean attribute read by PRESENCE would leave every group on a page insensitive.
+     */
+    get sensitive(): boolean;
+    set sensitive(value: boolean);
+    /** Whether the toggle at `index` is enabled (`AdwToggle:enabled`) — false once disabled. */
+    isToggleEnabled(index: number): boolean;
     /** Zero-based index of the active toggle. */
     get active(): number;
     set active(value: number);
@@ -30,4 +45,6 @@ export declare class AdwToggleGroup extends HTMLElement {
     private _readActiveAttr;
     private _selectIndex;
     private _render;
+    /** Select the first enabled toggle, if there is one — the C's "no active" repair. */
+    private _activateFirstEnabled;
 }

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

@@ -1,6 +1,9 @@
 import type { AdwViewStackPageInfo as CorePageInfo } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 export type AdwViewStackPageInfo = CorePageInfo<HTMLElement>;
 export declare class AdwViewStack extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];

package/lib/types/elements/checks.d.ts

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 /**
  * The markup + state shared by `<gtk-check-button>` and `<adw-radio>`.
  *
@@ -17,6 +18,9 @@ declare abstract class AdwCheckBase extends HTMLElement {
     protected abstract activate(): void;
     get checked(): boolean;
     set checked(value: boolean);
+    /** `Gtk.CheckButton:active`, the GObject name for {@link checked}. */
+    get active(): boolean;
+    set active(value: boolean);
     /** Whether the control is in the third, inconsistent state. */
     get indeterminate(): boolean;
     set indeterminate(value: boolean);
@@ -33,6 +37,8 @@ declare abstract class AdwCheckBase extends HTMLElement {
 }
 /** The Adwaita checkbox — `checkbutton > check` as a custom element. */
 export declare class GtkCheckButton extends AdwCheckBase {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): string[];
     protected get inputType(): 'checkbox';
     protected activate(): void;

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

@@ -1,6 +1,8 @@
 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;
     private _menubar;
     private _menubarObserver;
     static get observedAttributes(): string[];

package/lib/types/elements/gtk-drop-down.d.ts

@@ -1,5 +1,6 @@
 import './gtk-popover.js';
 import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 /**
  * A dropdown option — `value` is the stable id, `label` the shown text. An alias of
  * core's {@link AdwComboOption}, since the drop-down and the combo row are the same
@@ -7,6 +8,8 @@ import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
  */
 export type GtkDropDownOption = AdwComboOption;
 export declare class GtkDropDown extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _buttonEl;
     private _labelEl;
     private _popoverEl;

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

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class GtkEntry extends HTMLElement {
     /**
      * `protected`, not `private`: `GtkPasswordEntry` and `GtkSearchEntry` subclass this
@@ -8,9 +9,18 @@ export declare class GtkEntry extends HTMLElement {
     protected _input: HTMLInputElement;
     private _initialized;
     private _maxLength;
+    /** The text last announced, so `changed` fires on a real change only — as `gtk_editable_changed` does. */
+    private _announced;
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     static get observedAttributes(): string[];
     get value(): string;
     set value(v: string);
+    /** `Gtk.Editable:text`, the GObject name for {@link value}. */
+    get text(): string;
+    set text(v: string);
+    /** `changed` then `notify::text`, once per real change of the text, typed or set from code. */
+    private _announceText;
     /** `Gtk.Entry:max-length` — 0 means unlimited. Counted in CODE POINTS. */
     get maxLength(): number;
     set maxLength(value: number);

package/lib/types/elements/gtk-menu-button.d.ts

@@ -67,5 +67,7 @@ export declare class GtkMenuButton extends HTMLElement {
     private _parseMenuAttr;
     private _onPopoverToggled;
     private _render;
+    /** The registry's answer, unless the application wrote `actions` itself (ADR 0097 § 2). */
+    private _refreshActions;
     private _renderMenu;
 }

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

@@ -1,4 +1,5 @@
-import { GtkViewport } from './gtk-viewport.js';
+import type { AdwAdjustment } from '@gjsify/adwaita-core';
+import type { GtkViewport } from './gtk-viewport.js';
 /** `GtkPolicyType`'s four nicks; `automatic` is the pspec's default for both bars. */
 export type GtkPolicyType = 'always' | 'never' | 'automatic' | 'external';
 /** `GtkCornerType`'s four corners, `top-left` being the pspec's default. */
@@ -10,11 +11,16 @@ export type GtkDirectionType = 'forward' | 'backward';
 export declare class GtkScrolledWindow extends HTMLElement {
     private _viewport;
     private _bars;
+    /** The size clamps `_writeSize` last wrote, which are the only ones it may clear. */
+    private readonly _wroteSizes;
     private _shading;
     private _observer;
     private _hoverable;
     private _fadeTimer;
     private _built;
+    /** What an unbuilt window answers before it has a viewport to read. */
+    private readonly _standIn;
+    private readonly _adopted;
     static get observedAttributes(): string[];
     /** `GtkScrolledWindow:hscrollbar-policy` — `automatic` in the pspec. */
     get hscrollbarPolicy(): GtkPolicyType;
@@ -22,6 +28,18 @@ export declare class GtkScrolledWindow extends HTMLElement {
     /** `GtkScrolledWindow:vscrollbar-policy` — `automatic` in the pspec. */
     get vscrollbarPolicy(): GtkPolicyType;
     set vscrollbarPolicy(value: GtkPolicyType);
+    /** `gtk_scrolled_window_get_policy`: `[hscrollbar, vscrollbar]` as `Gtk.PolicyType` constants. */
+    get_policy(): [number, number];
+    /** `gtk_scrolled_window_set_policy`; a value that is not a `Gtk.PolicyType` throws, as GJS's enum marshalling does. */
+    set_policy(hscrollbar_policy: number, vscrollbar_policy: number): void;
+    /** `GtkScrollable:hadjustment` as the window reports it: the one it was given, else the viewport's. */
+    get hadjustment(): AdwAdjustment;
+    get vadjustment(): AdwAdjustment;
+    get_hadjustment(): AdwAdjustment;
+    get_vadjustment(): AdwAdjustment;
+    /** Adopts `adjustment` as what `get_hadjustment` answers; the scroll position keeps following the viewport. */
+    set_hadjustment(adjustment: AdwAdjustment): void;
+    set_vadjustment(adjustment: AdwAdjustment): void;
     /** `GtkScrolledWindow:window-placement` — where the contents sit against the bars. */
     get windowPlacement(): GtkCornerType;
     set windowPlacement(value: GtkCornerType);
@@ -73,7 +91,13 @@ export declare class GtkScrolledWindow extends HTMLElement {
     private get _useIndicators();
     /** Everything the pspec's own state decides: the classes, the bars, the sizes. */
     private _sync;
-    private _size;
+    /**
+     * One of the four clamps as inline style. An unwritten clamp clears only what THIS element
+     * wrote: `min-width` / `min-height` are also where a tree's `width-request` /
+     * `height-request` land (`GTK_WIDGET_SIZE_CSS`), and assigning '' unconditionally erased it.
+     * Where both are set the content clamp wins, which is the one the widget measures itself.
+     */
+    private _writeSize;
     /** The viewport's adjustment for one axis, which is where GTK reads the scrollbar's. */
     private _adjustment;
     /**

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

@@ -1,3 +1,4 @@
+import type { DispatchedSignals } from '../signals.js';
 /** `GtkStackTransitionType`, spelled as the GIR's enum nicks (gtkstack.c:95-121). */
 export type StackTransitionType = 'none' | 'crossfade' | 'slide-right' | 'slide-left' | 'slide-up' | 'slide-down' | 'slide-left-right' | 'slide-up-down' | 'over-up' | 'over-down' | 'over-left' | 'over-right' | 'under-up' | 'under-down' | 'under-left' | 'under-right' | 'over-up-down' | 'over-down-up' | 'over-left-right' | 'over-right-left' | 'rotate-left' | 'rotate-right' | 'rotate-left-right';
 /** The browser's page descriptor — the stand-in for the `GtkStackPage` GObject. */
@@ -18,6 +19,8 @@ export interface GtkStackPageInfo {
     child: HTMLElement;
 }
 export declare class GtkStack extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     /** The child that is visible, or `null` — C's `priv->visible_child`. */
     private _visible;
     /** C's `priv->last_visible_child`: the page being animated away. */

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

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

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

@@ -14,8 +14,14 @@ export declare class GtkWindow extends HTMLElement {
     /** Watches the strip for an author's titlebar arriving after the build. */
     private _titlebarObserver;
     static get observedAttributes(): string[];
-    /** `Gtk.Window:title` — the window's title. */
-    get title(): string | null;
+    /**
+     * `Gtk.Window:title` — the window's title.
+     *
+     * The getter answers `''` for no title, not `null`: a `string | null` getter is not assignable to
+     * `HTMLElement.title`, and the emitted `.d.ts` then fails every consumer that does not set
+     * `skipLibCheck`. The setter still takes `null` to clear it, as GTK does.
+     */
+    get title(): string;
     set title(value: string | null);
     /** `Gtk.Window:decorated` — whether the frame and its titlebar strip are drawn at all. */
     get decorated(): boolean;

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

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

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

@@ -0,0 +1,4 @@
+import { type GObjectDoor } from '@gjsify/adwaita-core';
+/** `Hexdump` → `gjsify-hexdump`, `GoVecNotify` → `gjsify-go-vec-notify`. */
+export declare function tagForTypeName(typeName: string): string;
+export declare const webDoor: GObjectDoor;

package/lib/types/gobject-door.spec.d.ts

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

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

@@ -0,0 +1,17 @@
+type Handler = (emitter: HTMLElement, ...args: unknown[]) => unknown;
+/** Whether `el` got its four methods from {@link installElementApi} (a registered class has the core's). */
+export declare function hasElementApi(el: object): boolean;
+/** Makes every change of `property` on `el` reach a `notify::<property>` listener, connected or not. */
+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;
+/** Gives `el` the instance API of a registered class, over the events it declares. */
+export declare function installElementApi(el: HTMLElement): void;
+/**
+ * The end of a bind the core's engine drives. An element speaks camelCase members where a `.blp`
+ * says `dash-name`, so a built element is wrapped to translate the name; a registered class
+ * already has the core's accessors and aliases and is returned as it is.
+ */
+export declare function endpointOf(el: HTMLElement): HTMLElement;
+export {};

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

@@ -0,0 +1,77 @@
+import { GtkAdjustment } from '@gjsify/adwaita-core';
+import type { Buffer } from '@gjsify/gtksource-core';
+export declare class GtkSourceView extends HTMLElement {
+    static get observedAttributes(): string[];
+    private readonly session;
+    private readonly driver;
+    private unsubscribe;
+    private built;
+    private readonly gutter;
+    private readonly backdrop;
+    private readonly area;
+    private readonly vadj;
+    private readonly hadj;
+    private direction;
+    constructor();
+    private syncAdjustments;
+    private readonly onAreaScroll;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** `GtkSource.View:buffer`. */
+    get buffer(): Buffer;
+    set buffer(value: Buffer);
+    get autoIndent(): boolean;
+    set autoIndent(value: boolean | string);
+    /** Held and read back; a textarea has no indent step to apply it to (ADR 0094). */
+    get indentWidth(): number;
+    set indentWidth(value: number | string);
+    get showLineNumbers(): boolean;
+    set showLineNumbers(value: boolean | string);
+    get highlightCurrentLine(): boolean;
+    set highlightCurrentLine(value: boolean | string);
+    get monospace(): boolean;
+    set monospace(value: boolean | string);
+    get editable(): boolean;
+    set editable(value: boolean | string);
+    /** `GtkTextView:cursor-visible` — whether the insertion cursor is drawn; TRUE by default. */
+    get cursorVisible(): boolean;
+    set cursorVisible(value: boolean | string);
+    get cursor_visible(): boolean;
+    set cursor_visible(value: boolean);
+    get_cursor_visible(): boolean;
+    set_cursor_visible(value: boolean): void;
+    get_editable(): boolean;
+    set_editable(value: boolean): void;
+    get highlight_current_line(): boolean;
+    set highlight_current_line(value: boolean);
+    get show_line_numbers(): boolean;
+    set show_line_numbers(value: boolean);
+    /** `GtkScrollable:vadjustment` — one stable adjustment that follows the textarea's scroll. */
+    get vadjustment(): GtkAdjustment;
+    get hadjustment(): GtkAdjustment;
+    get_vadjustment(): GtkAdjustment;
+    get_hadjustment(): GtkAdjustment;
+    /** `gtk_widget_set_direction`: held, and mirrored onto `dir` for LTR and RTL. */
+    set_direction(direction: number): void;
+    get_direction(): number;
+    /** A view has no widget children of its own here: its parts are the browser's. */
+    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;
+    get leftMargin(): number;
+    set leftMargin(value: number | string);
+    get rightMargin(): number;
+    set rightMargin(value: number | string);
+    get topMargin(): number;
+    set topMargin(value: number | string);
+    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;
+    disconnect(id: number): void;
+    /** The inner textarea, for focus and tests. */
+    get textarea(): HTMLTextAreaElement;
+}

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

@@ -0,0 +1,2 @@
+import './gtk-source-view.js';
+export declare const GtkSourceViewTest: () => Promise<void>;

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

@@ -0,0 +1,44 @@
+import type { EditorDriver, EditorHost, EditorLayout, EditorPalette, StyledRun } from '@gjsify/gtksource-core';
+export interface EditorParts {
+    readonly root: HTMLElement;
+    readonly area: HTMLTextAreaElement;
+    readonly backdrop: HTMLElement;
+    readonly gutter: HTMLElement;
+}
+export declare class WebEditorDriver implements EditorDriver {
+    private readonly parts;
+    private host;
+    private text;
+    private caret;
+    private reported;
+    private layout;
+    private readonly runs;
+    private scheduled;
+    private listening;
+    private palette;
+    private attached;
+    constructor(parts: EditorParts);
+    bind(host: EditorHost): void;
+    /** Starts listening to the textarea; the counterpart of the Android `attach()`. */
+    attach(): void;
+    detach(): void;
+    private onInput;
+    private onSelection;
+    /** `accepts-tab` is GTK's default; a textarea would move focus, so Tab inserts a tab. */
+    private onKey;
+    setText(text: string): void;
+    replaceRange(start: number, end: number, text: string): void;
+    setSelection(start: number, end: number): void;
+    setLineCount(): void;
+    setLayout(layout: EditorLayout): void;
+    /** Attributes and styles on the host wait for `attach()`: a custom element's constructor may not write them. */
+    private applyLayout;
+    setPalette(palette: EditorPalette): void;
+    private applyPalette;
+    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 render;
+}

package/lib/types/index.d.ts

@@ -6,12 +6,15 @@ export type { AdwAccentSource } from './appearance.js';
 export { AdwScrollShading } from './scroll-shading.js';
 export type { AdwUndershootEdges } from './scroll-shading.js';
 export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
-export type { MountedSharedTree, SizeSource } 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 * as Adw from './namespace/adw.js';
 export * as Gtk from './namespace/gtk.js';
 export * as Gio from './namespace/gio.js';
+export * as GLib from './namespace/glib.js';
+export * as GObject from './namespace/gobject.js';
+export * as GtkSource from './namespace/gtksource.js';
 export { AdwCard } from './elements/adw-card.js';
 export { AdwDataGrid } from './elements/adw-data-grid.js';
 export type { AdwDataGridAlign, AdwDataGridColumn, AdwDataGridRow, AdwDataGridRowVariant, } from './elements/adw-data-grid.js';

package/lib/types/menu-actions.spec.d.ts

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

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

@@ -54,3 +54,4 @@ export { AdwViewSwitcherBar as ViewSwitcherBar } from '../elements/adw-view-swit
 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';

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

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