@gjsify/adwaita-web 0.55.0 → 0.57.0

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

@@ -0,0 +1,10 @@
+export declare const PRIORITY_HIGH: number;
+export declare const PRIORITY_DEFAULT: number;
+export declare const PRIORITY_HIGH_IDLE: number;
+export declare const PRIORITY_DEFAULT_IDLE: number;
+export declare const PRIORITY_LOW: number;
+export declare const SOURCE_REMOVE: boolean;
+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;

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

@@ -0,0 +1,27 @@
+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 ParamSpec: typeof import("@gjsify/adwaita-core").ParamSpec;
+export declare const ParamFlags: {
+    readonly READABLE: 1;
+    readonly WRITABLE: 2;
+    readonly READWRITE: 3;
+    readonly CONSTRUCT: 4;
+    readonly CONSTRUCT_ONLY: 8;
+};
+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;
+export declare const TYPE_UINT: import("@gjsify/adwaita-core").GType;
+export declare const TYPE_DOUBLE: import("@gjsify/adwaita-core").GType;
+export declare const GTypeName: symbol;
+export declare const GTypeFlags: symbol;
+export declare const interfaces: symbol;
+export declare const properties: symbol;
+export declare const signals: symbol;
+export declare const requires: symbol;
+export declare const __gtkTemplate__: symbol;
+export declare const __gtkCssName__: symbol;
+export declare const __gtkChildren__: symbol;
+export declare const __gtkInternalChildren__: symbol;

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

@@ -0,0 +1,22 @@
+/** `Gtk.PolicyType`: `ALWAYS` 0, `AUTOMATIC` 1, `NEVER` 2, `EXTERNAL` 3. */
+export declare const PolicyType: Readonly<{
+    readonly ALWAYS: 0;
+    readonly AUTOMATIC: 1;
+    readonly NEVER: 2;
+    readonly EXTERNAL: 3;
+}>;
+/** `Gtk.TextDirection`: `NONE` 0, `LTR` 1, `RTL` 2. */
+export declare const TextDirection: Readonly<{
+    readonly NONE: 0;
+    readonly LTR: 1;
+    readonly RTL: 2;
+}>;
+/** `Gtk.TextWindowType`: `WIDGET` 1, `TEXT` 2, `LEFT` 3, `RIGHT` 4, `TOP` 5, `BOTTOM` 6. */
+export declare const TextWindowType: Readonly<{
+    readonly WIDGET: 1;
+    readonly TEXT: 2;
+    readonly LEFT: 3;
+    readonly RIGHT: 4;
+    readonly TOP: 5;
+    readonly BOTTOM: 6;
+}>;

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

@@ -1,4 +1,5 @@
 export { GtkAdjustment as Adjustment } from '@gjsify/adwaita-core';
+export { PolicyType, TextDirection, 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';
@@ -73,3 +74,4 @@ export { GtkWindow as Window } from '../elements/gtk-window.js';
 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';
+export { GtkApplication as Application } from '../application.js';

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

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

package/lib/types/row-line-clamp.d.ts

@@ -0,0 +1,20 @@
+export interface RowLineClampConfig {
+    titleEl: HTMLElement;
+    subtitleEl: HTMLElement;
+    textContainerEl: HTMLElement;
+    getTitleLines: () => number;
+    getSubtitleLines: () => number;
+}
+/**
+ * Apply or remove line clamping based on title-lines/subtitle-lines values.
+ * Uses CSS custom properties and class toggle (not inline styles).
+ */
+export declare function applyRowLineClamp(config: RowLineClampConfig): void;
+/**
+ * Parse a lines attribute value following AdwActionRow semantics:
+ * - Missing/null/empty → 0 (unlimited)
+ * - Invalid/non-numeric → 0 (unlimited)
+ * - n > 0 → n (clamp to n lines)
+ * - n <= 0 → 0 (unlimited; pspec range is 0..G_MAXINT)
+ */
+export declare function parseRowLinesAttribute(value: string | null): number;

package/lib/types/row-tooltip.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Apply `row`'s `tooltip-text` to `parts`, or clear it when the attribute is absent.
+ *
+ * `parts` are the row's OWN sections, never a slotted consumer widget — see the header.
+ * Each one is marked `data-row-tooltip`, which is the hook `scss/_row.scss` stretches so
+ * the tooltip covers the row rather than the label text inside it.
+ */
+export declare function applyRowTooltip(row: HTMLElement, parts: readonly Element[]): void;

package/lib/types/row-tooltip.spec.d.ts

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

package/lib/types/shared-tree-builder.d.ts

@@ -1,4 +1,4 @@
-import { type BreakpointSize } from '@gjsify/adwaita-core';
+import { type BreakpointSize, type TemplateScope } from '@gjsify/adwaita-core';
 import { type SharedTreeNode } from '@gjsify/adwaita-core/conformance';
 /** One authored placement, kept so {@link mountSharedTree} can hold the renderer to it. */
 interface PlacedChild {
@@ -30,6 +30,10 @@ interface BuildRecord {
     observeSize?: SizeSource;
     /** The object a signal handler's NAME is resolved against (ADR 0093 § 3), as `Gtk.BuilderScope` does. */
     scope?: Readonly<Record<string, unknown>>;
+    /** The root menus of the tree (ADR 0097), which a `menu-model: id` anywhere below resolves against. */
+    menus?: SharedTreeNode['menus'];
+    /** Present when the tree is the template of a registered class (ADR 0096): handlers and binds go through it. */
+    template?: TemplateScope;
 }
 /** Calls `onSize` with the host's measured size, now and on every change; returns its disposer. */
 export type SizeSource = (element: Element, onSize: (size: BreakpointSize) => void) => () => void;
@@ -44,21 +48,22 @@ interface PendingBind {
  * A `SharedTreeNode`, realised as a DETACHED element tree: a tag, its authored properties as
  * attributes, its style classes as classes, its extensions (ADR 0072) as the markup the element
  * reads, its placement as `slot=`, its children, in that order — recursive and total,
- * no tag list, no per-block case. A boolean authored property is the ATTRIBUTE'S PRESENCE
- * (`toggleAttribute`), which is what every element in the corpus reads
- * (`hasAttribute('revealed')`, `hasAttribute('expanded')`); spelling `"true"` would set a
- * present attribute for `false` as well.
+ * no tag list, no per-block case.
  *
- * EXCEPT AN AUTHORED `false` ON A PROPERTY THE ELEMENT DECLARES. Absence cannot say `false`
- * where the GTK default is TRUE — `AdwNavigationPage:can-pop`, `GtkActionBar:revealed` —
- * because those elements read an absent attribute as that default, so `can-pop: false`
- * reached the page as `can-pop` unset and the page stayed poppable. The element's own
- * property setter knows its attribute convention, so an authored `false` is written
- * through it when the element (already upgraded: `createElement` of a defined tag
- * constructs it) declares one; everything else keeps the presence rule. "Declares" means a
- * member it can WRITE ({@link isWritable}): a getter-only accessor of the same name — the
- * split button's and the menu button's read-only `active` — would throw a bare `TypeError`
- * out of the assignment, so such a property falls back to the presence rule too.
+ * BOOLEAN ATTRIBUTES are written per (widget, property), not per attribute name. The same
+ * attribute name (e.g. `revealed`) can be VALUE-BASED for one widget (`gtk-action-bar`,
+ * default TRUE) and PRESENCE-BASED for another (`adw-banner`, default FALSE). The
+ * per-widget map in `@gjsify/adwaita-core/tags` ({@link isValueBasedBooleanAttr}) records this.
+ *
+ * - VALUE-BASED: `attr="false"` means false, absent means true (the GTK default).
+ *   The builder writes `attr="true"|"false"` directly via {@link writeBooleanAttribute}.
+ * - PRESENCE-BASED (style classes like `flat`, `round`, `compact`): `toggleAttribute`
+ *   writes the bare attribute for `true`, removes it for `false`.
+ *
+ * EXCEPT an authored `false` on a NON-value-based, WRITABLE property: the property is set
+ * directly (bypassing the attribute) because the element's setter will reflect it correctly.
+ * A getter-only property of the same name (e.g. `AdwSplitButton.active`) falls back to the
+ * presence rule since assignment would throw.
  *
  * THE SLOT IS WRITTEN AS THE ATTRIBUTE THIS RENDERER ALREADY ROUTES ON, not translated:
  * `src/slotted-children.ts` reads `slot=` off every light-DOM child and keeps the routing
@@ -72,21 +77,65 @@ interface PendingBind {
  * upgraded has declared no slots yet, so the refusal below belongs to the mount.
  */
 export declare function buildSharedTree(node: SharedTreeNode, record?: BuildRecord): HTMLElement;
+/**
+ * One authored property, written as the element reads it; a breakpoint setter takes the same door.
+ *
+ * BOOLEAN ATTRIBUTES are written per (widget, property), not per attribute name. The same
+ * attribute name (e.g. `revealed`) can be VALUE-BASED for one widget (`gtk-action-bar`,
+ * default TRUE) and PRESENCE-BASED for another (`adw-banner`, default FALSE). The
+ * per-widget map in `@gjsify/adwaita-core/tags` ({@link isValueBasedBooleanAttr}) records this.
+ *
+ * - VALUE-BASED: `attr="false"` means false, absent means true (the GTK default).
+ *   The builder writes `attr="true"|"false"` directly via {@link writeBooleanAttribute}.
+ * - PRESENCE-BASED (style classes like `flat`, `round`, `compact`): `toggleAttribute`
+ *   writes the bare attribute for `true`, removes it for `false`.
+ *
+ * EXCEPT an authored `false` on a NON-value-based, WRITABLE property: the property is set
+ * directly (bypassing the attribute) because the element's setter will reflect it correctly.
+ * A getter-only property of the same name (e.g. `AdwSplitButton.active`) falls back to the
+ * presence rule since assignment would throw. `hexpand` / `vexpand` keep an authored `false`
+ * as the attribute `"false"` and a later `true` rewrites it — `GTK_WIDGET_EXPAND` says why.
+ */
+export declare function writeProp(el: HTMLElement, prop: string, value: string | number | boolean): void;
+/** A template tree built for a registered class: its children are not attached, its look is not written. */
+export interface BuiltTemplateTree {
+    readonly children: HTMLElement[];
+    /** Every object the template names with an `id`. */
+    readonly objects: Record<string, HTMLElement>;
+    /** Writes the root's own properties, classes and extensions onto the host — at its first connect. */
+    finish(): void;
+}
+/**
+ * The template of a registered class (ADR 0096 § 3), built into `host`: children created and wired
+ * to their handlers and binds through `scope`, none appended and nothing written to `host`'s
+ * attributes, because `host` is still inside its constructor. `finish` and the caller's own append
+ * belong to the first `connectedCallback`.
+ */
+export declare function buildTemplateTree(tree: SharedTreeNode, scope: TemplateScope, host: HTMLElement): BuiltTemplateTree;
 /** A tree {@link mountSharedTree} built and connected. */
 export interface MountedSharedTree {
     /** The authored root — connected, so every custom element under it has upgraded and run. */
     root: HTMLElement;
-    /** Disconnects and discards the mount point. */
+    /** Disconnects the tree, and discards the mount point when this call made one. */
     unmount: () => void;
 }
+/** What {@link mountSharedTree} takes beside the tree. */
+export interface MountOptions {
+    /** The object a handler NAME is looked up on (ADR 0093 § 3). */
+    scope?: Readonly<Record<string, unknown>>;
+    /** The size source a `breakpoints` node is driven from. */
+    observeSize?: SizeSource;
+    /**
+     * Where the root is appended — a showcase's own container, which then lays the window out.
+     * Without it the tree gets a fresh host `<div>` in `document.body`, discarded on `unmount`.
+     */
+    into?: HTMLElement;
+}
 /**
  * {@link buildSharedTree}, attached under a fresh host `<div>` in `document.body` so the tree
  * — and every custom element in it — is REAL rather than merely constructed. This is the
  * instantiation half a caller reading the corpus's elements normally wants; a bare
  * `buildSharedTree` is for a caller that already has somewhere of its own to attach it.
  */
-export declare function mountSharedTree(node: SharedTreeNode, options?: {
-    scope?: Readonly<Record<string, unknown>>;
-    observeSize?: SizeSource;
-}): MountedSharedTree;
+export declare function mountSharedTree(node: SharedTreeNode, options?: MountOptions): MountedSharedTree;
 export {};

package/lib/types/shared-tree-mount.spec.d.ts

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