@gjsify/adwaita-core 0.59.1 → 0.61.0

package/lib/types/conformance/gtk-platform.d.ts

@@ -0,0 +1,49 @@
+import type { ConstructHarness } from './constructs.js';
+/** The part of `Gtk` the vectors read. */
+export interface GtkPlatformLike {
+    readonly CssProvider: new () => {
+        load_from_string(css: string): void;
+        to_string(): string;
+    };
+    readonly Settings: {
+        get_default(): {
+            gtk_font_name: string | null;
+        };
+    };
+    readonly IconTheme: {
+        get_for_display(display: unknown): {
+            add_resource_path(path: string): void;
+            get_resource_path(): string[];
+        };
+    };
+    readonly EventControllerKey: new () => {
+        connect(signal: string, handler: (...args: unknown[]) => boolean | void): number;
+        disconnect(id: number): void;
+    };
+    readonly StyleContext: {
+        add_provider_for_display(display: unknown, provider: object, priority: number): void;
+        remove_provider_for_display(display: unknown, provider: object): void;
+    };
+    readonly STYLE_PROVIDER_PRIORITY_FALLBACK: number;
+    readonly STYLE_PROVIDER_PRIORITY_THEME: number;
+    readonly STYLE_PROVIDER_PRIORITY_SETTINGS: number;
+    readonly STYLE_PROVIDER_PRIORITY_APPLICATION: number;
+    readonly STYLE_PROVIDER_PRIORITY_USER: number;
+    show_uri: unknown;
+}
+/** What a driver hands the vectors. */
+export interface GtkPlatformSubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly Gtk: GtkPlatformLike;
+}
+export declare const GTK_PLATFORM_ROWS: readonly ["priorities", "provider", "settings", "icon-theme", "controller", "members"];
+export type GtkPlatformRow = (typeof GTK_PLATFORM_ROWS)[number];
+export interface GtkPlatformVector {
+    readonly row: GtkPlatformRow;
+    readonly rule: string;
+    readonly observe: (subject: GtkPlatformSubject) => unknown;
+    readonly shows: unknown;
+}
+export declare const GTK_PLATFORM_VECTORS: readonly GtkPlatformVector[];
+export declare function driveGtkPlatformVectors(subject: GtkPlatformSubject, harness: ConstructHarness, vectors?: readonly GtkPlatformVector[]): Promise<void>;

package/lib/types/conformance/index.d.ts

@@ -89,6 +89,8 @@ export { APPLICATION_ROWS, APPLICATION_VECTORS, driveApplicationVectors, unprove
 export type { ApplicationLike, ApplicationRow, ApplicationScene, ApplicationSubject, ApplicationVector, SimpleActionLike, } from './application.js';
 export { GLIB_TIMER_ROWS, GLIB_TIMER_VECTORS, driveGLibTimerVectors } from './glib-timers.js';
 export type { GLibTimerRow, GLibTimersLike, GLibTimersSubject, GLibTimerVector } from './glib-timers.js';
+export { GTK_PLATFORM_ROWS, GTK_PLATFORM_VECTORS, driveGtkPlatformVectors } from './gtk-platform.js';
+export type { GtkPlatformLike, GtkPlatformRow, GtkPlatformSubject, GtkPlatformVector } from './gtk-platform.js';
 export type { GObjectRow, GObjectSubject, GObjectTemplateSource, GObjectVector } from './gobject.js';
 export { POPUP_MENU_PLAN_VECTORS, popupMenuOutline } from './popup-menu-plan.js';
 export type { PopupMenuPlanVector } from './popup-menu-plan.js';
@@ -104,3 +106,5 @@ export { SIMPLE_ACTION_GROUP_ROWS, SIMPLE_ACTION_GROUP_VECTORS, driveSimpleActio
 export type { GioActionsLike, SimpleActionGroupLike, SimpleActionGroupRow, SimpleActionGroupSubject, SimpleActionGroupVector, GioSimpleActionLike, } from './simple-action-group.js';
 export { GDK_CLIPBOARD_ROWS, GDK_CLIPBOARD_VECTORS, driveGdkClipboardVectors } from './gdk-clipboard.js';
 export type { GdkClipboardNamespaces, GdkClipboardRow, GdkClipboardSubject, GdkClipboardVector, } from './gdk-clipboard.js';
+export { FILE_CHOOSER_ROWS, FILE_CHOOSER_VECTORS, driveFileChooserVectors, promisifyFileChooser, } from './file-chooser.js';
+export type { FileChooserNamespaces, FileChooserRow, FileChooserSubject, FileChooserVector, ScriptedPick, } from './file-chooser.js';

package/lib/types/conformance/style-manager.d.ts

@@ -6,12 +6,22 @@ export interface StyleManagerLike {
         name: string;
     }) => void): number;
     disconnect(id: number): void;
+    color_scheme: number;
+    get_color_scheme(): number;
+    set_color_scheme(scheme: number): void;
 }
 /** The part of `Adw` the vectors read. */
 export interface AdwStyleLike {
     StyleManager: {
         get_default(): StyleManagerLike;
     };
+    ColorScheme: {
+        DEFAULT: number;
+        FORCE_LIGHT: number;
+        PREFER_LIGHT: number;
+        PREFER_DARK: number;
+        FORCE_DARK: number;
+    };
 }
 export interface StyleManagerSubject {
     readonly name: string;
@@ -21,7 +31,7 @@ export interface StyleManagerSubject {
     setDark(dark: boolean): void;
     settle(): Promise<void>;
 }
-export declare const STYLE_MANAGER_ROWS: readonly ["default", "dark", "notify", "unchanged", "disconnect", "readonly"];
+export declare const STYLE_MANAGER_ROWS: readonly ["default", "dark", "notify", "unchanged", "disconnect", "readonly", "scheme-values", "scheme-force", "scheme-notify", "scheme-default"];
 export type StyleManagerRow = (typeof STYLE_MANAGER_ROWS)[number];
 export interface StyleManagerVector {
     readonly row: StyleManagerRow;

package/lib/types/engine-slot.spec.d.ts

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

package/lib/types/engine.d.ts

@@ -0,0 +1,71 @@
+import type { Binding, BindingFlag, GObjectInstance, ParamSpec, RegisteredClass, SignalHandler } from './gobject.js';
+export interface GObjectEngine {
+    /** Names the engine in a diagnostic; `'pure-js'` for the default one. */
+    readonly name: string;
+    /**
+     * A class finished registering. The engine may build whatever per-class thing it needs from
+     * `info.properties` and `info.signals` (a real engine registers a GType here). The core has
+     * already applied every refusal, so `info` is inside the subset.
+     */
+    register(info: RegisteredClass): void;
+    /**
+     * The value of `spec` on `instance`. Until something sets it this is `spec.get_default_value()`
+     * — a property reads as its default, which is a vector of its own.
+     */
+    getValue(instance: object, spec: ParamSpec): unknown;
+    /**
+     * Stores `value` — ALWAYS, which is what makes this the construct-only writer too — and
+     * returns whether the CORE must notify. For a store that only holds values that is "did this
+     * change anything", and the pure-JS engine answers exactly that: an unset slot counts as
+     * changed even for a value equal to the default, as `_generateAccessors` does.
+     *
+     * It is deliberately the core's DUTY and not the engine's CHANGE, because an engine whose
+     * write already emits `notify` — a real-GObject one, where `g_object_set_property` notifies
+     * itself — would otherwise have to suppress the second one. Such an engine returns false
+     * always and the notification still happens, once, from inside the store. The core never
+     * notifies for the construct write either way.
+     */
+    setValue(instance: object, spec: ParamSpec, value: unknown): boolean;
+    /**
+     * Connects `handler` under the core's `id`. `key` is a plain signal name or
+     * `notify::<property>`, already resolved against the class chain and canonical (the dashed
+     * spelling of the property).
+     */
+    addHandler(instance: GObjectInstance, id: number, key: string, handler: SignalHandler): void;
+    /** Disconnects the handler the core gave `id` to; false when this engine has no such id. */
+    removeHandler(instance: GObjectInstance, id: number): boolean;
+    /**
+     * Runs the handlers of `key`. The core has already checked that `key` is a signal of the class
+     * and that the argument count matches its `param_types`. A handler is called as
+     * `handler(instance, ...args)` — the JS instance, never an engine-internal twin.
+     */
+    emit(instance: GObjectInstance, key: string, args: readonly unknown[]): void;
+    /** Emits `notify::<spec.name>`. Separate from {@link emit} because real GObject's notify is. */
+    notify(instance: GObjectInstance, spec: ParamSpec): void;
+    /**
+     * Marks the innermost emission of `key` in progress so the handlers after the current one do
+     * not run. False when there is none, which the core turns into GLib's warning.
+     */
+    stopEmission(instance: GObjectInstance, key: string): boolean;
+    /**
+     * `g_object_bind_property` for the three flags the template builders use. An engine with real
+     * bindings returns a real `GBinding`'s `unbind`; the pure-JS one follows `notify`.
+     */
+    bind(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags: readonly BindingFlag[]): Binding;
+}
+/**
+ * Makes `engine` the engine behind every GObject namespace a port builds AFTER this call. Throws
+ * when the slot has already been read, or when a DIFFERENT engine holds it — re-registering the
+ * same one is idempotent, so a module two bundles both evaluate is not an error.
+ *
+ * Nothing calls this in the core. `@gjsify/adwaita-gobject-native`'s `useRealGObjectEngine` is the
+ * one caller the workspace has, and it is the app that calls that.
+ */
+export declare function registerGObjectEngine(engine: GObjectEngine): void;
+/**
+ * The engine a port must build its namespace on, or `undefined` when none was registered — which
+ * the caller is to read as "use the default", not as an error. Freezes the slot.
+ */
+export declare function registeredEngine(): GObjectEngine | undefined;
+/** Forgets the slot. For tests, which need a second app's worth of module state in one process. */
+export declare function resetRegisteredEngine(): void;

package/lib/types/file-chooser.d.ts

@@ -0,0 +1,171 @@
+import { Bytes } from './glib-bytes.js';
+import { GLibError } from './glib-error.js';
+import { type GType } from './gobject.js';
+/** What a `Gtk.FileFilter` holds, as a driver reads it. */
+export interface FileFilterSpec {
+    readonly name: string | null;
+    /** `add_pattern("*.ext")`: the extension, without the dot. Case-sensitive, as GTK's. */
+    readonly patterns: readonly string[];
+    /** `add_suffix("ext")`: case-insensitive, as GTK's. */
+    readonly suffixes: readonly string[];
+    readonly mimeTypes: readonly string[];
+    /** `add_pattern("*")` or `add_mime_type("*\/*")`: the filter accepts every file. */
+    readonly acceptAll: boolean;
+}
+/** One open or save, as the dialog hands it to the driver. */
+export interface FileChooserRequest {
+    readonly title: string | null;
+    readonly filters: readonly FileFilterSpec[];
+    readonly defaultFilter: FileFilterSpec | null;
+    readonly initialName: string | null;
+    /** The `parent` passed to `open`/`save`; the web ignores it, Android may use it as the owner. */
+    readonly parent: unknown;
+}
+/** The platform's handle behind a `Gio.File`: bytes, not a path. */
+export interface FileChooserHandle {
+    readonly basename: string;
+    /** The URI GIO would give (`content://…` on Android); absent where there is none to give. */
+    readonly uri?: string;
+    read(): Promise<Uint8Array>;
+    /** Opens for writing and truncates. `close()` commits. */
+    openWriter(): Promise<FileChooserWriter>;
+}
+export interface FileChooserWriter {
+    write(chunk: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Opens the platform's picker. A user who closes it rejects with a `GLib.Error` of
+ * `Gtk.DialogError.DISMISSED` ({@link dismissedError}); anything else that rejects becomes
+ * `Gtk.DialogError.FAILED` with the cause in the message.
+ */
+export interface FileChooserDriver {
+    open(request: FileChooserRequest): Promise<FileChooserHandle>;
+    save(request: FileChooserRequest): Promise<FileChooserHandle>;
+}
+/** Puts `next` below every `Gtk.FileDialog`; returns the driver it replaced. A gjsify extra, not GTK. */
+export declare function registerFileChooserDriver(next: FileChooserDriver | null): FileChooserDriver | null;
+export declare function dismissedError(message?: string): GLibError;
+export declare function dialogFailedError(message: string): GLibError;
+type AsyncReadyCallback = ((source: object, result: AsyncResult) => void) | null;
+type Outcome = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: unknown;
+};
+/** `Gio.AsyncResult`: opaque to the caller, read once by the matching `_finish`. */
+declare class AsyncResult {
+    #private;
+    constructor(source: object, tag: string, outcome: Outcome);
+    get_source_object(): object;
+    static take(result: unknown, source: object, tag: string): unknown;
+}
+/**
+ * `Gio._promisify(proto, asyncName, finishName)`: called without its callback, `asyncName` returns a
+ * Promise of what `finishName` returns, a leading `true` dropped. A missing method throws here, as GJS's.
+ */
+export declare function promisify(proto: object, asyncName: string, finishName?: string): void;
+export declare class FileFilter {
+    static readonly $gtype: GType;
+    constructor(params?: Record<string, unknown>);
+    static new(): FileFilter;
+    get name(): string | null;
+    set name(value: string | null);
+    get_name(): string | null;
+    set_name(name: string | null): void;
+    /** `*` or `*.ext`; any other glob is refused, since no picker below takes one. */
+    add_pattern(pattern: string): void;
+    add_suffix(suffix: string): void;
+    /** `type/subtype`, `type/*` or `*\/*`. A driver that cannot honour `type/*` refuses it when it opens. */
+    add_mime_type(mimeType: string): void;
+}
+export declare function fileFilterSpec(filter: FileFilter): FileFilterSpec;
+/** Whether `basename` passes `spec` by name. MIME types do not judge a name; a MIME-only filter passes. */
+export declare function fileFilterAccepts(spec: FileFilterSpec, basename: string): boolean;
+/** The store `Gtk.FileDialog.filters` takes: `item_type` `Gtk.FileFilter.$gtype`, `append` to fill it. */
+export declare class GioListStore {
+    #private;
+    constructor(params?: {
+        item_type?: GType;
+        itemType?: GType;
+    });
+    get item_type(): GType;
+    get n_items(): number;
+    append(item: object): void;
+    get_n_items(): number;
+    get_item(position: number): object | null;
+    get_item_type(): GType;
+}
+export declare const FileCreateFlags: Readonly<{
+    NONE: 0;
+    PRIVATE: 1;
+    REPLACE_DESTINATION: 2;
+}>;
+export declare class OutputStream {
+    /** @internal */
+    constructor(writer: FileChooserWriter);
+    write_bytes_async(bytes: Bytes, _io_priority: number, cancellable: unknown, callback: AsyncReadyCallback): void;
+    write_bytes_finish(result: unknown): number;
+    close_async(_io_priority: number, cancellable: unknown, callback: AsyncReadyCallback): void;
+    close_finish(result: unknown): boolean;
+    is_closed(): boolean;
+}
+export declare class FileOutputStream extends OutputStream {
+}
+export declare class GioFile {
+    /** @internal */
+    constructor(handle: FileChooserHandle);
+    static new_for_path(): never;
+    static new_for_uri(): never;
+    static new_for_commandline_arg(): never;
+    get_basename(): string;
+    /** `null`, as GJS gives for a file with no local path (a portal `content://` file). */
+    get_path(): string | null;
+    get_uri(): string;
+    load_contents_async(cancellable: unknown, callback: AsyncReadyCallback): void;
+    /** `[true, contents, etag]`; the etag is `null` here (ADR 0100 § 3). */
+    load_contents_finish(result: unknown): [boolean, Uint8Array, string | null];
+    replace_contents_async(contents: Uint8Array | Bytes, etag: string | null, make_backup: boolean, flags: number, cancellable: unknown, callback: AsyncReadyCallback): void;
+    /** `[true, new_etag]`; the etag is `null` here. */
+    replace_contents_finish(result: unknown): [boolean, string | null];
+    replace_async(etag: string | null, make_backup: boolean, flags: number, _io_priority: number, cancellable: unknown, callback: AsyncReadyCallback): void;
+    replace_finish(result: unknown): FileOutputStream;
+}
+/** A `Gio.File` over `handle`, for a driver to resolve `open`/`save` with. */
+export declare function fileForHandle(handle: FileChooserHandle): GioFile;
+export declare class FileDialog {
+    #private;
+    constructor(params?: Record<string, unknown>);
+    static new(): FileDialog;
+    get title(): string | null;
+    set title(value: string | null);
+    get_title(): string | null;
+    set_title(title: string | null): void;
+    get modal(): boolean;
+    set modal(value: boolean);
+    get_modal(): boolean;
+    set_modal(modal: boolean): void;
+    get filters(): GioListStore | null;
+    set filters(value: GioListStore | null);
+    get_filters(): GioListStore | null;
+    set_filters(filters: GioListStore | null): void;
+    get initial_name(): string | null;
+    set initial_name(value: string | null);
+    get initialName(): string | null;
+    set initialName(value: string | null);
+    get_initial_name(): string | null;
+    set_initial_name(name: string | null): void;
+    get default_filter(): FileFilter | null;
+    set default_filter(value: FileFilter | null);
+    get defaultFilter(): FileFilter | null;
+    set defaultFilter(value: FileFilter | null);
+    get_default_filter(): FileFilter | null;
+    set_default_filter(filter: FileFilter | null): void;
+    open(parent: unknown, cancellable: unknown, callback: AsyncReadyCallback): void;
+    open_finish(result: unknown): GioFile;
+    save(parent: unknown, cancellable: unknown, callback: AsyncReadyCallback): void;
+    save_finish(result: unknown): GioFile;
+}
+export {};

package/lib/types/file-chooser.gjs.spec.d.ts

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

package/lib/types/file-chooser.spec.d.ts

@@ -0,0 +1,5 @@
+import { type FileFilterSpec } from './file-chooser.js';
+/** How the vectors write a filter: `*.ext` per pattern or suffix, `*` for accept-all, MIME types as given. */
+export declare function filterGlobs(spec: FileFilterSpec): string[];
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/glib-bytes.d.ts

@@ -0,0 +1,11 @@
+export declare class Bytes {
+    #private;
+    constructor(data: Uint8Array);
+    static new(data: Uint8Array): Bytes;
+    static new_take(): never;
+    static new_static(): never;
+    get_size(): number;
+    get_data(): Uint8Array;
+    /** @internal The bytes without a copy, for the stream that writes them. */
+    static view(bytes: Bytes): Uint8Array;
+}

package/lib/types/glib-error.d.ts

@@ -0,0 +1,28 @@
+/** `Gtk.DialogError`: what `Gtk.FileDialog` rejects with. A user closing the dialog is `DISMISSED`. */
+export declare const DialogError: Readonly<{
+    FAILED: number;
+    CANCELLED: number;
+    DISMISSED: number;
+}>;
+/** `Gio.IOErrorEnum`, the codes the `Gio.File` subset raises. */
+export declare const IOErrorEnum: Readonly<{
+    FAILED: number;
+    NOT_FOUND: number;
+    NOT_SUPPORTED: number;
+    CLOSED: number;
+    CANCELLED: number;
+    PENDING: number;
+}>;
+export declare class GLibError {
+    readonly domain: number;
+    readonly code: number;
+    readonly message: string;
+    readonly stack: string;
+    constructor(domain: unknown, code: number, message: string);
+    matches(domain: unknown, code: number): boolean;
+    toString(): string;
+    static new_literal(): never;
+    copy(): never;
+}
+/** `error` as it reaches a caller: a `GLib.Error` passes through, anything else becomes `code` in `domain`. */
+export declare function asGLibError(error: unknown, domain: object, code: number): GLibError;

package/lib/types/gobject.d.ts

@@ -1,4 +1,5 @@
 import type { SharedTreeNode } from './conformance/shared-trees.js';
+import type { GObjectEngine } from './engine.js';
 /** What `registerClass` accepts as `Template`: the projected tree of a `?template` import (ADR 0096 § 4). */
 export type BlueprintTemplate = SharedTreeNode;
 /** The subset asked for something it does not list. `feature` is the name that was refused. */
@@ -116,6 +117,8 @@ export interface RegisteredClass {
     readonly internalChildren: readonly string[];
     readonly cssName?: string;
     readonly door: GObjectDoor;
+    /** Where instances of this class keep their values and handlers (ADR 0105 § 2). */
+    readonly engine: GObjectEngine;
 }
 export declare function registeredClassOf(klass: object): RegisteredClass | undefined;
 export type SignalHandler = (emitter: GObjectInstance, ...args: unknown[]) => unknown;
@@ -127,6 +130,11 @@ export interface GObjectInstance {
     disconnect(id: number): void;
     emit(signal: string, ...args: unknown[]): void;
 }
+/**
+ * The default {@link GObjectEngine}: per-instance `Map`s behind a `WeakMap`, the only one the
+ * browser can have. Registration needs nothing of it — a `$gtype` here is a token, not a GType.
+ */
+export declare const PURE_JS_ENGINE: GObjectEngine;
 /**
  * How an object that is no registered class (the GtkSource buffer and view) takes part in
  * `signal_stop_emission_by_name`: it keeps its own emissions and stops the innermost one of the
@@ -192,7 +200,7 @@ export declare const UNLOCKED_VFUNCS: Readonly<Record<string, readonly string[]>
  * resolve through the registry like a registered class's own. The door is one that names the
  * missing widget model: such a class has no event system to fall through to.
  */
-export declare function registerBaseClass(klass: ClassLike, typeName: string, signals: Readonly<Record<string, readonly GType[]>>, properties?: readonly ParamSpec[]): void;
+export declare function registerBaseClass(klass: ClassLike, typeName: string, signals: Readonly<Record<string, readonly GType[]>>, properties?: readonly ParamSpec[], engine?: GObjectEngine): void;
 export type GObjectConstructor = new (params?: Record<string, unknown>) => GObjectInstance;
 /** `GObject.Object` for a registered class with no widget model beneath it. */
 export declare class GObjectObject {
@@ -204,6 +212,12 @@ export declare class GObjectObject {
     emit(signal: string, ...args: unknown[]): void;
 }
 export interface GObjectNamespace {
+    /**
+     * Names the {@link GObjectEngine} THIS namespace was built on — `'pure-js'` for the default.
+     * The answer to "what actually backs the subset in this app", asked of the only thing that
+     * cannot be wrong about it; {@link gobjectEngineName} is the same answer without a handle.
+     */
+    readonly engineName: string;
     readonly Object: GObjectConstructor;
     readonly registerClass: RegisterClass;
     readonly ParamSpec: typeof ParamSpec;
@@ -228,7 +242,19 @@ export interface GObjectNamespace {
     signal_stop_emission_by_name(instance: GObjectInstance, detailedSignal: string): void;
 }
 /**
- * The `GObject` namespace of a port: `registerClass` registers against `door`. There is no
- * `bind_property` here until a consumer calls it (ADR 0096 § 2); the engine is {@link bindProperties}.
+ * The `GObject` namespace of a port: `registerClass` registers against `door`, and instances of
+ * what it registers keep their values and handlers in `engine` (ADR 0105 § 2) — the pure-JS one
+ * unless a port passes another. There is no `bind_property` here until a consumer calls it
+ * (ADR 0096 § 2); the binding engine is the engine's `bind`, {@link bindProperties} by default.
+ */
+export declare function createGObject(door: GObjectDoor, engine?: GObjectEngine): GObjectNamespace;
+/**
+ * Which engine a namespace built from here would be on — `'pure-js'` unless something called
+ * `registerGObjectEngine`. The runtime answer to "is the subset backed by real GObject in this
+ * build", for an app that wants to log it or a test that wants to assert it, and the reason no
+ * caller ever needs a try/catch to find out.
+ *
+ * Asking FREEZES the slot, exactly as a port's read does: an answer a later registration would
+ * turn into a lie is worse than no answer. See `engine.ts` § "The slot".
  */
-export declare function createGObject(door: GObjectDoor): GObjectNamespace;
+export declare function gobjectEngineName(): string;

package/lib/types/gobject.node-gi.spec.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@gjsify/node-gi/gi`'s default export, as much of it as this suite uses: the namespace loader.
+ * Declared here rather than imported for the reason in the header — the bridge's own types are not
+ * resolvable in a job that has not linked it.
+ */
+export type RequireGi = (namespace: string, version?: string) => unknown;
+export declare const gobjectNodeGiSuite: (requireGi: RequireGi) => () => Promise<void>;

package/lib/types/gtk-platform.d.ts

@@ -0,0 +1,104 @@
+/** What a key event carries into {@link EventControllerKey}. `key` is a DOM `KeyboardEvent.key`. */
+export interface HostKeyEvent {
+    readonly key: string;
+    readonly keycode: number;
+    /** `Gdk.ModifierType` bits. */
+    readonly state: number;
+    readonly pressed: boolean;
+}
+/** How a port reaches the platform. Every member may be absent on a platform that has no such thing. */
+export interface PlatformHost {
+    /** Replaces the style sheet of `owner`; an empty list removes it. The host orders by priority. */
+    setStyles(sheets: readonly {
+        owner: object;
+        css: string;
+        priority: number;
+    }[]): void;
+    openUri(uri: string): void;
+    /** The system UI font as `"Name Size"`, or `null` when the platform does not say. */
+    fontName(): string | null;
+    /** Listens for keys on `widget`; `handler` returns whether it handled the key. */
+    listenKeys(widget: object, handler: (event: HostKeyEvent) => boolean): () => void;
+}
+export declare const STYLE_PROVIDER_PRIORITY_FALLBACK = 1;
+export declare const STYLE_PROVIDER_PRIORITY_THEME = 200;
+export declare const STYLE_PROVIDER_PRIORITY_SETTINGS = 400;
+export declare const STYLE_PROVIDER_PRIORITY_APPLICATION = 600;
+export declare const STYLE_PROVIDER_PRIORITY_USER = 800;
+/** `Gdk.CURRENT_TIME`. */
+export declare const CURRENT_TIME = 0;
+/** The X11 keysyms (`Gdk.KEY_*`) an application writes a key map in; the numbers are GDK's. */
+export declare const GDK_KEYS: Readonly<{
+    readonly KEY_space: 32;
+    readonly KEY_a: 97;
+    readonly KEY_d: 100;
+    readonly KEY_e: 101;
+    readonly KEY_q: 113;
+    readonly KEY_s: 115;
+    readonly KEY_w: 119;
+    readonly KEY_Return: 65293;
+    readonly KEY_Escape: 65307;
+    readonly KEY_Left: 65361;
+    readonly KEY_Up: 65362;
+    readonly KEY_Right: 65363;
+    readonly KEY_Down: 65364;
+}>;
+/** A DOM `key` as the keysym GTK would deliver: a Latin-1 character is its own code point, lowercased. */
+export declare function keyvalOfKey(key: string): number;
+/** `Gtk.CssProvider`: `load_from_string` is the one loader the subset carries. */
+export declare class CssProvider {
+    #private;
+    load_from_string(css: string): void;
+    to_string(): string;
+    /** @internal */
+    static bind(provider: CssProvider, onChange: (() => void) | null): void;
+}
+/** `Gtk.Settings`: `gtk_font_name`, held once written. */
+export declare class GtkSettings {
+    #private;
+    /** @internal */
+    constructor(host: PlatformHost);
+    get gtk_font_name(): string | null;
+    set gtk_font_name(name: string | null);
+}
+/** `Gtk.IconTheme`: the resource paths an application adds; the port's icon registry is the lookup. */
+export declare class IconTheme {
+    #private;
+    add_resource_path(path: string): void;
+    get_resource_path(): string[];
+}
+type KeyHandler = (controller: EventControllerKey, keyval: number, keycode: number, state: number) => boolean | void;
+/** `Gtk.EventControllerKey`: `key-pressed` and `key-released`, the first one's return value counts. */
+export declare class EventControllerKey {
+    #private;
+    connect(signal: string, handler: KeyHandler): number;
+    disconnect(id: number): void;
+    /** @internal */
+    static attach(controller: EventControllerKey, detach: (() => void) | null): void;
+    /** @internal Runs the handlers of one key event; true when one of them took the key. */
+    static dispatch(controller: EventControllerKey, event: HostKeyEvent): boolean;
+}
+/** `Gtk` and `Gdk` as far as this slice goes. */
+export interface GtkPlatform {
+    readonly CssProvider: typeof CssProvider;
+    readonly StyleContext: {
+        add_provider_for_display(display: unknown, provider: CssProvider, priority: number): void;
+        remove_provider_for_display(display: unknown, provider: CssProvider): void;
+    };
+    readonly Settings: {
+        get_default(): GtkSettings;
+    };
+    readonly IconTheme: {
+        get_for_display(display: unknown): IconTheme;
+    };
+    readonly EventControllerKey: typeof EventControllerKey;
+    show_uri(parent: unknown, uri: string, timestamp: number): void;
+}
+/** A port is always on a display, so `Settings.get_default()` is never null (real GTK: null before `Gtk.init`). */
+export declare function createGtkPlatform(host: PlatformHost): GtkPlatform;
+/** `Gtk.Widget.add_controller` / `remove_controller` for the widgets of a port. */
+export declare function widgetControllerMembers(host: PlatformHost): {
+    add_controller(this: object, controller: EventControllerKey): void;
+    remove_controller(this: object, controller: EventControllerKey): void;
+};
+export {};

package/lib/types/gtk-platform.spec.d.ts

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

package/lib/types/index.d.ts

@@ -51,9 +51,16 @@ export { DEFAULT_LABEL_ELLIPSIZE, DEFAULT_LABEL_LINES, DEFAULT_LABEL_MAX_WIDTH_C
 export type { LabelAlignItems, LabelEllipsizeMode, LabelJustification, LabelWidthCharsExtent, LabelWrapMode, } from './label.js';
 export { glibClamp, gStrStrip, stringIsNotEmpty } from './glib.js';
 export { ContentFormats, ContentProvider, Clipboard, Display, createGdk, widgetDisplayMembers } from './gdk.js';
+export { CURRENT_TIME, CssProvider, EventControllerKey, GDK_KEYS, GtkSettings, IconTheme, STYLE_PROVIDER_PRIORITY_APPLICATION, STYLE_PROVIDER_PRIORITY_FALLBACK, STYLE_PROVIDER_PRIORITY_SETTINGS, STYLE_PROVIDER_PRIORITY_THEME, STYLE_PROVIDER_PRIORITY_USER, createGtkPlatform, keyvalOfKey, widgetControllerMembers, } from './gtk-platform.js';
+export type { GtkPlatform, HostKeyEvent, PlatformHost } from './gtk-platform.js';
+export { syncDirection, widgetTreeMembers } from './widget-members.js';
 export type { ClipboardHost, GdkClipboard } from './gdk.js';
 export { createGLibTimers } from './glib-timers.js';
 export type { GLibTimers, SourceFunc, TimerHost } from './glib-timers.js';
+export { GLibError, DialogError, IOErrorEnum, asGLibError } from './glib-error.js';
+export { Bytes as GLibBytes } from './glib-bytes.js';
+export { FileDialog as GtkFileDialog, FileFilter as GtkFileFilter, GioFile, GioListStore, OutputStream as GioOutputStream, FileOutputStream as GioFileOutputStream, FileCreateFlags, promisify, registerFileChooserDriver, fileForHandle, fileFilterSpec, fileFilterAccepts, dismissedError, dialogFailedError, } from './file-chooser.js';
+export type { FileChooserDriver, FileChooserHandle, FileChooserRequest, FileChooserWriter, FileFilterSpec, } from './file-chooser.js';
 export { ViewStackState, normalizeIconName, resolvePageTitle } from './view-stack.js';
 export type { AdwViewStackPageInfo, AdwViewStackPageSpec, ViewStackStateChange, ViewStackStateListener, } from './view-stack.js';
 export { BACK_BUTTON_FALLBACK_TOOLTIP, NavigationViewState, describeNavigationDiagnostic } from './navigation-view.js';
@@ -110,12 +117,14 @@ export { ADW_WRAP_BOX_DEFAULT_ALIGN, ADW_WRAP_BOX_DEFAULT_JUSTIFY, ADW_WRAP_BOX_
 export type { AdwWrapBoxJustify, AdwWrapBoxOrientation, AdwWrapBoxPackDirection, AdwWrapPolicy, WrapBoxChildFlex, WrapBoxChildOrderOp, WrapBoxFlexInput, WrapBoxFlexStyle, WrapBoxLineLayout, } from './wrap-box.js';
 export { ADW_SOURCE_6502_DIRECTIVES, ADW_SOURCE_6502_LINE_COMMENT, ADW_SOURCE_6502_OPCODES, ADW_SOURCE_6502_REGISTERS, ADW_SOURCE_6502_TOKEN_ROLES, ADW_SOURCE_HEX_STRIDE, ADW_SOURCE_PALETTE_DARK, ADW_SOURCE_PALETTE_LIGHT, ADW_SOURCE_SYNTAX_ROLES, classifyAsm6502Word, formatHexAddress, formatLineNumber, stripSourceWhitespace, tokenizeAsm6502, } from './source.js';
 export type { AdwSourcePalette, AdwSourceSyntaxRole, AdwSourceTokenClass, AdwSourceTokenStream } from './source.js';
-export { GObjectObject, META_SYMBOLS, ParamFlags, ParamSpec, Value, TYPE_BOOLEAN, TYPE_DOUBLE, TYPE_INT, TYPE_STRING, TYPE_UINT, UnsupportedGObjectError, bindProperties, connectInstance, constructRegistered, createClosure, createGObject, disconnectInstance, emitInstance, notifyInstance, registeredClassOf, registerBaseClass, STOP_EMISSION, type StoppableEmitter, UNLOCKED_VFUNCS, GIR_TYPE, } from './gobject.js';
+export { GObjectObject, META_SYMBOLS, ParamFlags, ParamSpec, Value, TYPE_BOOLEAN, TYPE_DOUBLE, TYPE_INT, TYPE_STRING, TYPE_UINT, UnsupportedGObjectError, bindProperties, connectInstance, constructRegistered, createClosure, createGObject, disconnectInstance, emitInstance, gobjectEngineName, notifyInstance, PURE_JS_ENGINE, registeredClassOf, registerBaseClass, STOP_EMISSION, type StoppableEmitter, UNLOCKED_VFUNCS, GIR_TYPE, } from './gobject.js';
 export { ApplicationFlags, GioApplicationBase, GtkApplicationBase, withGtkApplication, isValidApplicationId, } from './application.js';
 export type { ApplicationHost, GtkApplicationMembers, GtkApplicationConstructor } from './application.js';
 export { ActionRegistry, SimpleAction, actionRegistryOf, activateWidgetAction, applicationOfWindow, findActionGroup, insertActionGroup, installActionMap, linkWindow, SimpleActionGroup, } from './gio-actions.js';
 export type { ActionActivateHandler, ActionGroupLike, ActionLike, SimpleActionProps } from './gio-actions.js';
 export type { Binding, BindingFlag, BlueprintTemplate, BuiltTemplate, ClassLike, ClassMeta, GObjectConstructor, GObjectDoor, GObjectInstance, GObjectNamespace, GType, ParamKind, RegisterClass, RegisteredClass, SignalHandler, SignalMeta, TemplateScope, } from './gobject.js';
+export { registerGObjectEngine, registeredEngine, resetRegisteredEngine } from './engine.js';
+export type { GObjectEngine } from './engine.js';
 export { MAXUINT32, buildFilenamev, getCurrentDir, getSystemDataDirs } from './glib-paths.js';
-export { StyleManagerBase } from './style-manager.js';
+export { ColorScheme, StyleManagerBase } from './style-manager.js';
 export type { StyleSource } from './style-manager.js';

package/lib/types/style-manager.d.ts

@@ -4,11 +4,25 @@ export interface StyleSource {
     dark(): boolean;
     /** Calls `changed` whenever `dark()` may have changed; returns the unsubscribe. */
     subscribe(changed: () => void): () => void;
+    /** Pins the interface dark or light; `null` hands it back to the system. */
+    force?(dark: boolean | null): void;
 }
+/** `Adw.ColorScheme`, with the values of the GIR. */
+export declare const ColorScheme: {
+    readonly DEFAULT: 0;
+    readonly FORCE_LIGHT: 1;
+    readonly PREFER_LIGHT: 2;
+    readonly PREFER_DARK: 3;
+    readonly FORCE_DARK: 4;
+};
 export declare class StyleManagerBase extends GObjectObject {
     static [GIR_TYPE]: string;
     static source: StyleSource | undefined;
     static get_default(): StyleManagerBase;
     get dark(): boolean;
     get_dark(): boolean;
+    get color_scheme(): number;
+    set color_scheme(scheme: number);
+    get_color_scheme(): number;
+    set_color_scheme(scheme: number): void;
 }