@gjsify/adwaita-web 0.64.1 → 0.64.2-next.254

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

@@ -1,6 +1,7 @@
 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;
+export declare function notifyElement(el: HTMLElement, name: string): void;
 /** 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. */
@@ -13,6 +14,20 @@ export declare function dispatchElement(el: HTMLElement, signal: string, args: r
  * declares `sensitive` (`<adw-toggle-group>`) keeps its own.
  */
 export declare function installSensitive(el: HTMLElement): void;
+/** The `visible` getters `WidgetElement` puts on its prototype, so a class's own accessor tells apart. */
+export declare const WIDGET_VISIBLE_GETTERS: WeakSet<() => boolean>;
+/**
+ * Whether `el` has the port's `visible` — from `installVisible` or from `WidgetElement`. An
+ * element with its own `visible` (`<gtk-stack-page>`) keeps its own and answers false.
+ */
+export declare function hasInstalledVisible(el: Element): boolean;
+/**
+ * `Gtk.Widget:visible` for an element that has no member of that name: `gtk_widget_get_visible`
+ * and `gtk_widget_set_visible` over the DOM's `hidden` attribute, TRUE until hidden as GtkWidget's
+ * default is. It notifies only where the element declares `notify::visible`. An element that already declares `visible` (`<gtk-stack-page>`, `<adw-sidebar>`)
+ * keeps its own, and so does a registered class whose prototype has the port's members.
+ */
+export declare function installVisible(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/gtksource/gtk-source-view.d.ts

@@ -1,7 +1,8 @@
 import { GtkAdjustment } from '@gjsify/adwaita-core';
 import type { Buffer, Gutter } from '@gjsify/gtksource-core';
 import { STOP_EMISSION } from '@gjsify/gtksource-core';
-export declare class GtkSourceView extends HTMLElement {
+import { WidgetElement } from '../widget-element.js';
+export declare class GtkSourceView extends WidgetElement {
     static get observedAttributes(): string[];
     private readonly session;
     private readonly driver;

package/lib/types/{icon-registry.spec.d.ts → icon-masks.spec.d.ts}

@@ -15,4 +15,4 @@ export declare const maskOf: (el: HTMLElement) => string;
  * them, and the first version of this file passed that way while asserting nothing.
  */
 export declare function fallbackMask(): string;
-export declare const AdwIconRegistryTest: () => Promise<void>;
+export declare const AdwIconMasksTest: () => Promise<void>;

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

@@ -1,17 +1,11 @@
 import { type IconDirection } from '@gjsify/adwaita-core';
 /** 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 file under a `Gtk.IconTheme` resource path; `symbolic` files are masks in `currentColor`.
  * `url` is `null` when the browser cannot draw the file (XPM, compressed): draw `image-missing`.
  */
- | {
+{
     kind: 'resource';
     name: string;
     path: string;
@@ -29,17 +23,13 @@ export type IconLookup =
 };
 /** 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 neither a colour registration nor a resource holds a name, the request is returned as a
- * symbolic one 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
- * symbolic glyph and a colour entry or file.
+ * When no resource holds a name, the request is returned as a symbolic one WITHOUT checking
+ * the cascade: the mask class falls back to `image-missing` through CSS by itself. The cascade
+ * is read only to choose between a symbolic glyph and a resource file.
  */
 export declare function lookupIcon(iconName: string | null | undefined, request?: IconRequest): IconLookup | null;
 /** What a `GtkImage` hands its theme besides the name: its size, scale and text direction. */
@@ -51,29 +41,19 @@ export interface IconRequest {
     readonly direction?: IconDirection;
 }
 /**
- * The lookup over the colour registrations and the theme's resource paths; `null` when neither
- * answers any name, a `symbolic` entry when the current theme's glyph comes first.
+ * The lookup over the theme's resource paths; `null` when no resource answers any name, a
+ * `symbolic` entry when the current theme's glyph comes first.
  */
 export declare function resourceIcon(iconName: string, request: IconRequest): IconLookup | null;
 /**
- * Whether `iconName` resolves to something other than `image-missing` — a registered colour
- * icon, a file under a resource path, 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.
+ * Whether `name` draws something other than `image-missing` — a file under a `Gtk.IconTheme`
+ * resource path, or a symbolic glyph compiled into the stylesheet. The name is looked up
+ * exactly as `<gtk-image icon-name>` looks it up.
  *
- * CLIENT-SIDE ONLY, like `registerIcon`: it reads `document`.
+ * 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 deliberately the
+ * CUSTOM PROPERTY that is read and not the rendered `mask-image` of a probe element: since
+ * `_icon.scss` gives every icon box the `image-missing` fallback, a rendered mask is never
+ * `none`, and comparing against the fallback would answer `false` for `image-missing` itself.
  */
-export declare function registerColorIcon(name: string, source: string): void;
+export declare function isIconAvailable(name: string): boolean;

package/lib/types/index.d.ts

@@ -5,11 +5,10 @@ export { adwaitaAccentSource, applyDesktopAppearance, applySystemAccent, followD
 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 { MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
+export { buildSharedTree, buildWithSiblings, mountSharedTree } from './shared-tree-builder.js';
+export type { BuildOptions, BuiltTree, 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 { isIconAvailable } 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/learn6502-window.spec.d.ts

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

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

@@ -56,4 +56,4 @@ 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';
 export { AdwStyleManager as StyleManager } from '../style-manager.js';
-export { ColorScheme } from '@gjsify/adwaita-core';
+export { ColorScheme, Toast, ToastPriority } from '@gjsify/adwaita-core';

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

@@ -5,5 +5,6 @@ export declare const Display: {
 export declare const Clipboard: typeof import("@gjsify/adwaita-core").Clipboard;
 export declare const ContentProvider: Pick<typeof import("@gjsify/adwaita-core").ContentProvider, "new_for_value">;
 export declare const ContentFormats: typeof import("@gjsify/adwaita-core").ContentFormats;
+export declare const AppLaunchContext: typeof import("@gjsify/adwaita-core").GdkAppLaunchContext;
 export declare const CURRENT_TIME = 0;
 export declare const KEY_space: 32, KEY_a: 97, KEY_d: 100, KEY_e: 101, KEY_q: 113, KEY_s: 115, KEY_w: 119, KEY_Return: 65293, KEY_Escape: 65307, KEY_Left: 65361, KEY_Up: 65362, KEY_Right: 65363, KEY_Down: 65364;

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

@@ -5,3 +5,4 @@ export { SimpleAction, SimpleActionGroup, ApplicationFlags } from '@gjsify/adwai
 export { GioResource as Resource, ResourceError, ResourceLookupFlags, resources_enumerate_children, resources_get_info, resources_lookup_data, resources_register, resources_unregister, } from '@gjsify/adwaita-core';
 export { GioApplication as Application } from '../application.js';
 export { Settings } from '@gjsify/app-settings/browser';
+export declare const AppInfo: import("@gjsify/adwaita-core").GioAppInfo;

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

@@ -1,5 +1,5 @@
 export { GLibBytes as Bytes, GLibError as Error } from '@gjsify/adwaita-core';
-import { buildFilenamev, getCurrentDir, getSystemDataDirs } from '@gjsify/adwaita-core';
+import { buildFilenamev, getCurrentDir, getSystemDataDirs, uriEscapeString } from '@gjsify/adwaita-core';
 export declare const PRIORITY_HIGH: number;
 export declare const PRIORITY_DEFAULT: number;
 export declare const PRIORITY_HIGH_IDLE: number;
@@ -14,3 +14,4 @@ export declare const MAXUINT32 = 4294967295;
 export declare const build_filenamev: typeof buildFilenamev;
 export declare const get_current_dir: typeof getCurrentDir;
 export declare const get_system_data_dirs: typeof getSystemDataDirs;
+export declare const uri_escape_string: typeof uriEscapeString;

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

@@ -62,6 +62,7 @@ export { GtkSeparator as Separator } from '../elements/gtk-separator.js';
 export { GtkSpinButton as SpinButton } from '../elements/gtk-spin-button.js';
 export { GtkSpinner as Spinner } from '../elements/gtk-spinner.js';
 export { GtkStack as Stack } from '../elements/gtk-stack.js';
+export { GtkStackPage as StackPage } from '../elements/gtk-stack-page.js';
 export { GtkStackSidebar as StackSidebar } from '../elements/gtk-stack-sidebar.js';
 export { GtkStackSwitcher as StackSwitcher } from '../elements/gtk-stack-switcher.js';
 export { GtkStringList as StringList } from '@gjsify/adwaita-core';
@@ -76,6 +77,7 @@ 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';
+export { ApplicationInhibitFlags } from '@gjsify/adwaita-core';
 export { GtkApplication as Application } from '../application.js';
 export { STYLE_PROVIDER_PRIORITY_APPLICATION, STYLE_PROVIDER_PRIORITY_FALLBACK, STYLE_PROVIDER_PRIORITY_SETTINGS, STYLE_PROVIDER_PRIORITY_THEME, STYLE_PROVIDER_PRIORITY_USER, } from '@gjsify/adwaita-core';
 export { CssProvider, EventControllerKey, IconTheme, show_uri, StyleContext, Settings } from './gtk-platform.js';

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

@@ -77,6 +77,37 @@ 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;
+/** What {@link buildWithSiblings} hands back: the root element and the objects built beside it. */
+export interface BuiltTree {
+    /** The element the tree roots at, as {@link buildSharedTree} returns it. */
+    root: HTMLElement;
+    /**
+     * The sibling objects by id — `Adw.AlertDialog unsavedChangesDialog { }` or `$Learn learn { }`
+     * written after the template. A sibling is built in the root's id scope (a setter or a bind
+     * may name it) but is no child of the root: the code beside the file decides where, or
+     * whether, it is placed.
+     */
+    siblings: ReadonlyMap<string, HTMLElement>;
+    /** Every element the tree names by id, siblings included: what `GtkBuilder.get_object` answers for. */
+    objects: ReadonlyMap<string, HTMLElement>;
+}
+/** What {@link buildWithSiblings} takes beside the tree. */
+export interface BuildOptions {
+    /** 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;
+}
+/**
+ * A tree with sibling roots (ADR 0093): the root element, and each sibling by id, all DETACHED
+ * like {@link buildSharedTree}'s result.
+ *
+ * {@link buildSharedTree}, {@link mountSharedTree} and {@link buildTemplateTree} refuse such a
+ * tree by name, because they return one element and the siblings would be built and then thrown
+ * away. A sibling with no id is refused too: nothing could ever ask for it, which is how a
+ * dropped object looks finished.
+ */
+export declare function buildWithSiblings(node: SharedTreeNode, options?: BuildOptions): BuiltTree;
 /**
  * One authored property, written as the element reads it; a breakpoint setter takes the same door.
  *

package/lib/types/signals.d.ts

@@ -1,4 +1,8 @@
 /** GTK signal name → the DOM event type the element dispatches it as. */
 export type DispatchedSignals = Readonly<Record<string, string>>;
-/** The signals `el`'s class declares, or none. */
+/**
+ * The signals `el`'s class and every class above it declare, or none. A class inherits its
+ * base's signals as a GObject class does (`map` / `unmap` are declared once, on
+ * `WidgetElement`); where two declare the same name, the more derived class wins.
+ */
 export declare function dispatchedSignalsOf(el: Element): DispatchedSignals;

package/lib/types/source-view/adw-source-view.d.ts

@@ -1,5 +1,6 @@
 import { EditorView } from '@codemirror/view';
-export declare class AdwSourceView extends HTMLElement {
+import { WidgetElement } from '../widget-element.js';
+export declare class AdwSourceView extends WidgetElement {
     private _view?;
     private _editorHost;
     private _copyButton;