@gjsify/adwaita-core 0.64.12-next.279 → 0.64.12-next.281

package/lib/esm/rgba.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";var RGBA=class{constructor(e={}){this.red=e.red??0,this.green=e.green??0,this.blue=e.blue??0,this.alpha=e.alpha??0}equal(e){return this.red===e.red&&this.green===e.green&&this.blue===e.blue&&this.alpha===e.alpha}to_string(){let channel=e=>Math.round(Math.min(1,Math.max(0,e))*255),e=`${channel(this.red)},${channel(this.green)},${channel(this.blue)}`;return this.alpha===1?`rgb(${e})`:`rgba(${e},${Number(this.alpha.toPrecision(6))})`}};export{RGBA};

package/lib/esm/style-manager.js

@@ -1 +1 @@
-import"./_virtual/_rolldown/runtime.js";import{GIR_TYPE as e,GObjectObject as t,ParamFlags as n,ParamSpec as r,registerBaseClass as i}from"./gobject.js";const a={DEFAULT:0,FORCE_LIGHT:1,PREFER_LIGHT:2,PREFER_DARK:3,FORCE_DARK:4},o=new WeakMap,s=new WeakMap,c=new WeakMap;function refresh(e){if(!o.has(e))return;let t=sourceOf(e).dark();o.get(e)!==t&&(o.set(e,t),e.notify(`dark`))}function sourceOf(e){let t=e.constructor.source;if(t===void 0)throw Error(`Adw.StyleManager: this class has no StyleSource; use the Adw.StyleManager of a port.`);return t}var StyleManagerBase=class extends t{static{this[e]=`Adw.StyleManager`}static get_default(){let e=s.get(this);if(e===void 0){e=new this,s.set(this,e);let t=sourceOf(e);o.set(e,t.dark()),t.subscribe(()=>refresh(e))}return e}get dark(){return sourceOf(this).dark()}get_dark(){return this.dark}get system_supports_color_schemes(){return sourceOf(this).supportsColorSchemes?.()??!1}get_system_supports_color_schemes(){return this.system_supports_color_schemes}get color_scheme(){return c.get(this)??a.DEFAULT}set color_scheme(e){if(!Object.values(a).includes(e))throw Error(`Adw.StyleManager: ${e} is not an Adw.ColorScheme`);if(e===this.color_scheme)return;c.set(this,e);let t=e===a.FORCE_DARK?!0:e===a.FORCE_LIGHT?!1:null;sourceOf(this).force?.(t),this.notify(`color-scheme`),refresh(this)}get_color_scheme(){return this.color_scheme}set_color_scheme(e){this.color_scheme=e}};i(StyleManagerBase,`AdwStyleManager`,{},[r.boolean(`dark`,``,``,n.READABLE,!1),r.boolean(`system-supports-color-schemes`,``,``,n.READABLE,!1),r.int(`color-scheme`,``,``,n.READWRITE,0,4,0)]);export{a as ColorScheme,StyleManagerBase};
+import"./_virtual/_rolldown/runtime.js";import{GIR_TYPE as e,GObjectObject as t,ParamFlags as n,ParamSpec as r,registerBaseClass as i}from"./gobject.js";import{ADW_ACCENT_COLOR_NAMES as a,adwaitaAccentBgColor as o,adwaitaAccentColor as s,parseAdwRgb as c}from"./accent.js";import{RGBA as l}from"./rgba.js";const u={DEFAULT:0,FORCE_LIGHT:1,PREFER_LIGHT:2,PREFER_DARK:3,FORCE_DARK:4},d={BLUE:0,TEAL:1,GREEN:2,YELLOW:3,ORANGE:4,RED:5,PINK:6,PURPLE:7,SLATE:8,to_rgba:e=>rgbaOf(o(nameOf(e))),to_standalone_rgba:(e,t)=>rgbaOf(s(nameOf(e),t))};function nameOf(e){return a[e]??`blue`}function rgbaOf(e){let t=c(e);return new l({red:t.red,green:t.green,blue:t.blue,alpha:1})}const f=new WeakMap;function read(e){let t=e.accentColor?.()??null;return{dark:e.dark(),contrast:e.highContrast?.()??!1,accent:t===null?d.BLUE:a.indexOf(t)}}const p=new WeakMap,m=new WeakMap;function refresh(e){if(!f.has(e))return;let t=f.get(e),n=read(sourceOf(e));f.set(e,n),n.dark!==t.dark&&e.notify(`dark`),n.contrast!==t.contrast&&e.notify(`high-contrast`),n.accent!==t.accent&&e.notify(`accent-color`)}function sourceOf(e){let t=e.constructor.source;if(t===void 0)throw Error(`Adw.StyleManager: this class has no StyleSource; use the Adw.StyleManager of a port.`);return t}var StyleManagerBase=class extends t{static{this[e]=`Adw.StyleManager`}static get_default(){let e=p.get(this);if(e===void 0){e=new this,p.set(this,e);let t=sourceOf(e);f.set(e,read(t)),t.subscribe(()=>refresh(e))}return e}get dark(){return sourceOf(this).dark()}get_dark(){return this.dark}get system_supports_color_schemes(){return sourceOf(this).supportsColorSchemes?.()??!1}get_system_supports_color_schemes(){return this.system_supports_color_schemes}get high_contrast(){return sourceOf(this).highContrast?.()??!1}get_high_contrast(){return this.high_contrast}get system_supports_accent_colors(){return(sourceOf(this).accentColor?.()??null)!==null}get_system_supports_accent_colors(){return this.system_supports_accent_colors}get accent_color(){return read(sourceOf(this)).accent}get_accent_color(){return this.accent_color}get accent_color_rgba(){return d.to_rgba(this.accent_color)}get_accent_color_rgba(){return this.accent_color_rgba}get color_scheme(){return m.get(this)??u.DEFAULT}set color_scheme(e){if(!Object.values(u).includes(e))throw Error(`Adw.StyleManager: ${e} is not an Adw.ColorScheme`);if(e===this.color_scheme)return;m.set(this,e);let t=e===u.FORCE_DARK?!0:e===u.FORCE_LIGHT?!1:null;sourceOf(this).force?.(t),this.notify(`color-scheme`),refresh(this)}get_color_scheme(){return this.color_scheme}set_color_scheme(e){this.color_scheme=e}};i(StyleManagerBase,`AdwStyleManager`,{},[r.boolean(`dark`,``,``,n.READABLE,!1),r.boolean(`system-supports-color-schemes`,``,``,n.READABLE,!1),r.boolean(`high-contrast`,``,``,n.READABLE,!1),r.boolean(`system-supports-accent-colors`,``,``,n.READABLE,!1),r.int(`accent-color`,``,``,n.READABLE,0,8,0),r.int(`color-scheme`,``,``,n.READWRITE,0,4,0)]);export{d as AccentColor,u as ColorScheme,StyleManagerBase};

package/lib/esm/widget-members.js

@@ -1 +1 @@
-import"./_virtual/_rolldown/runtime.js";import{insertActionGroup as e}from"./gio-actions.js";const t=[0,1,2],n=new WeakMap;function syncDirection(e){let t=n.get(e);t===void 0||!e.isConnected||(t===0?e.removeAttribute(`dir`):e.dir=t===2?`rtl`:`ltr`)}function widgetTreeMembers(){return{set_direction(e){if(!t.includes(e))throw TypeError(`${e} is not a valid value for enum argument dir`);n.set(this,e),syncDirection(this)},get_direction(){return n.get(this)??1},get_visible(){return!this.hasAttribute(`hidden`)},set_visible(e){this.toggleAttribute(`hidden`,!e)},get_first_child(){return this.firstElementChild},get_last_child(){return this.lastElementChild},get_next_sibling(){return this.nextElementSibling},get_prev_sibling(){return this.previousElementSibling},get_parent(){return this.parentElement},add_css_class(e){this.classList.add(e)},remove_css_class(e){this.classList.remove(e)},has_css_class(e){return this.classList.contains(e)},insert_action_group(t,n){e(this,t,n)}}}export{syncDirection,widgetTreeMembers};
+import"./_virtual/_rolldown/runtime.js";import{insertActionGroup as e}from"./gio-actions.js";import{computePoint as t}from"./graphene.js";const n=[0,1,2],r=new WeakMap;function syncDirection(e){let t=r.get(e);t===void 0||!e.isConnected||(t===0?e.removeAttribute(`dir`):e.dir=t===2?`rtl`:`ltr`)}function widgetTreeMembers(){return{set_direction(e){if(!n.includes(e))throw TypeError(`${e} is not a valid value for enum argument dir`);r.set(this,e),syncDirection(this)},get_direction(){return r.get(this)??1},get_visible(){return!this.hasAttribute(`hidden`)},set_visible(e){this.toggleAttribute(`hidden`,!e)},get_first_child(){return this.firstElementChild},get_last_child(){return this.lastElementChild},get_next_sibling(){return this.nextElementSibling},get_prev_sibling(){return this.previousElementSibling},get_parent(){return this.parentElement},get_width(){return this.offsetWidth},get_height(){return this.offsetHeight},compute_point(e,n){return t(this,e,n)},add_css_class(e){this.classList.add(e)},remove_css_class(e){this.classList.remove(e)},has_css_class(e){return this.classList.contains(e)},insert_action_group(t,n){e(this,t,n)}}}export{syncDirection,widgetTreeMembers};

package/lib/esm/window-members.js

@@ -1 +1 @@
-import"./_virtual/_rolldown/runtime.js";var WindowMemberState=class{constructor(e,t={}){this._active=!1,this._focus=null,this._notify=e,this._maximized=t.maximized??!1}get active(){return this._active}get maximized(){return this._maximized}get focus(){return this._focus}reportActive(e){return this._active===e?!1:(this._active=e,this._notify(`is-active`),!0)}reportMaximized(e){return this._maximized===e?!1:(this._maximized=e,this._notify(`maximized`),!0)}reportFocus(e){return this._focus===e?!1:(this._focus=e,this._notify(`focus-widget`),!0)}},HandledAccumulator=class{constructor(){this._handled=!1}get stopped(){return this._handled}collect(e){e&&(this._handled=!0)}},CloseRequestState=class{constructor(){this._emitting=!1}get emitting(){return this._emitting}close(e){if(!e.realized||this._emitting)return`ignored`;let t;this._emitting=!0;try{e.emit()?t=`handled`:e.hideOnClose?(e.hide(),t=`hidden`):t=`destroyed`}finally{this._emitting=!1}return t===`destroyed`&&e.destroy(),t}};export{CloseRequestState,HandledAccumulator,WindowMemberState};
+import"./_virtual/_rolldown/runtime.js";var WindowMemberState=class{constructor(e,t={}){this._active=!1,this._focus=null,this._notify=e,this._maximized=t.maximized??!1}get active(){return this._active}get maximized(){return this._maximized}get focus(){return this._focus}reportActive(e){return this._active===e?!1:(this._active=e,this._notify(`is-active`),!0)}reportMaximized(e){return this._maximized===e?!1:(this._maximized=e,this._notify(`maximized`),!0)}reportFocus(e){return this._focus===e?!1:(this._focus=e,this._notify(`focus-widget`),!0)}};function stepDefaultSize(e,t,n){if(!Number.isInteger(t)||!Number.isInteger(n)||t<-1||n<-1)return null;let r=[];return n!==e[1]&&r.push(`default-height`),t!==e[0]&&r.push(`default-width`),{width:t,height:n,changed:r}}var HandledAccumulator=class{constructor(){this._handled=!1}get stopped(){return this._handled}collect(e){e&&(this._handled=!0)}},CloseRequestState=class{constructor(){this._emitting=!1}get emitting(){return this._emitting}close(e){if(!e.realized||this._emitting)return`ignored`;let t;this._emitting=!0;try{e.emit()?t=`handled`:e.hideOnClose?(e.hide(),t=`hidden`):t=`destroyed`}finally{this._emitting=!1}return t===`destroyed`&&e.destroy(),t}};export{CloseRequestState,HandledAccumulator,WindowMemberState,stepDefaultSize};

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

@@ -1,7 +1,7 @@
 import type { BindingFlag, BlueprintTemplate, GObjectConstructor, GObjectInstance, GObjectNamespace } from '../gobject.js';
 import type { ConstructHarness } from './constructs.js';
 /** The rows of ADR 0096 § 2 that carry a claim; every one needs a vector. */
-export declare const GOBJECT_ROWS: readonly ["registerClass", "field-form", "ParamSpec", "Signals", "instance API", "type_ensure", "vfunc", "binding engine", "template"];
+export declare const GOBJECT_ROWS: readonly ["registerClass", "field-form", "ParamSpec", "Signals", "instance API", "type_ensure", "vfunc", "binding engine", "template", "interface", "object property"];
 export type GObjectRow = (typeof GOBJECT_ROWS)[number];
 /** A template, in both spellings: GtkBuilder XML for GJS, the projected tree for a port. */
 export interface GObjectTemplateSource {
@@ -19,6 +19,24 @@ export interface GObjectSubject {
     readonly Widget?: GObjectConstructor;
     /** The value to put in `Template`. */
     template(source: GObjectTemplateSource): unknown;
+    /**
+     * The `Gio.ListModel` token a vector puts in `Implements` — the real interface on an oracle,
+     * the core's token on the subset. Absent where no Gio is reachable, which skips those rows.
+     */
+    readonly ListModel?: unknown;
+    /**
+     * Something carrying a READ-WRITE object-kind property called `model` whose value type is
+     * `Gio.ListModel`, and a value that property accepts.
+     *
+     * A REAL C object (`Gtk.DropDown` + `Gtk.StringList`) on the oracles, because a JS-registered
+     * class is not one for this row: GJS's auto-accessors store without a GValue conversion, so a
+     * JS class would accept every value the C property refuses and the refusal vectors would
+     * measure nothing. It needs a display, so an oracle offers it only where Gtk initialised.
+     */
+    objectProperty?(): {
+        readonly instance: GObjectInstance;
+        readonly accepted: GObjectInstance;
+    };
     /** The binding engine; `bind_property` on GJS, which is not exported by the ports. */
     bind(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags: readonly BindingFlag[]): void;
 }
@@ -27,6 +45,10 @@ export interface GObjectVector {
     readonly rule: string;
     readonly holds: 'oracle' | 'subset';
     readonly widget?: true;
+    /** Needs {@link GObjectSubject.ListModel}; skipped where the subject has no Gio. */
+    readonly iface?: true;
+    /** Needs {@link GObjectSubject.objectProperty}; skipped where the subject cannot build one. */
+    readonly objectProperty?: true;
     readonly observe: (subject: GObjectSubject) => unknown;
     readonly shows: unknown;
 }

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

@@ -110,6 +110,8 @@ export { GLIB_URI_ROWS, GLIB_URI_VECTORS, driveGLibUriVectors } from './glib-uri
 export type { GLibUriLike, GLibUriRow, GLibUriSubject, GLibUriVector } from './glib-uri.js';
 export { GLIB_VARIANT_ROWS, GLIB_VARIANT_VECTORS, driveGLibVariantVectors } from './glib-variant.js';
 export type { GLibVariantLike, GLibVariantRow, GLibVariantSubject, GLibVariantVector, VariantClassLike, VariantLike, } from './glib-variant.js';
+export { RGBA_ROWS, RGBA_VECTORS, driveRGBAVectors } from './rgba.js';
+export type { GdkRGBALike, RGBALike, RGBARow, RGBASubject, RGBAVector } from './rgba.js';
 export { GLIB_UNICHAR_ROWS, GLIB_UNICHAR_VECTORS, driveGLibUnicharVectors } from './glib-unichar.js';
 export type { GLibUnicharLike, GLibUnicharRow, GLibUnicharSubject, GLibUnicharVector } from './glib-unichar.js';
 export { GIO_APP_INFO_ROWS, GIO_APP_INFO_VECTORS, driveGioAppInfoVectors } from './gio-app-info.js';

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

@@ -0,0 +1,46 @@
+import type { ConstructHarness } from './constructs.js';
+export interface RGBALike {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+    equal(other: RGBALike): boolean;
+    to_string(): string;
+}
+/** The part of `Gdk` the vectors read. */
+export interface GdkRGBALike {
+    RGBA: new (init?: {
+        red?: number;
+        green?: number;
+        blue?: number;
+        alpha?: number;
+    }) => RGBALike;
+}
+export interface RGBASubject {
+    readonly name: string;
+    readonly isOracle: boolean;
+    readonly Gdk: GdkRGBALike;
+}
+export declare const RGBA_ROWS: readonly ["opaque", "alpha", "rounding", "equal"];
+export type RGBARow = (typeof RGBA_ROWS)[number];
+export interface RGBAVector {
+    readonly row: RGBARow;
+    readonly rule: string;
+    readonly a: {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    };
+    /** The second colour `equal()` is asked about; absent for the string rows. */
+    readonly b?: {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    };
+    /** `to_string()` of `a`, or `equal()` as "true"/"false". */
+    readonly shows: string;
+}
+export declare const RGBA_VECTORS: readonly RGBAVector[];
+export declare function driveRGBAVectors(subject: RGBASubject, harness: ConstructHarness, vectors?: readonly RGBAVector[]): Promise<void>;

package/lib/types/conformance/window-members.d.ts

@@ -1,5 +1,5 @@
 import type { ConstructHarness } from './constructs.js';
-export declare const WINDOW_ROWS: readonly ["close-request", "close", "hide-on-close", "maximized", "focus-widget"];
+export declare const WINDOW_ROWS: readonly ["close-request", "close", "hide-on-close", "maximized", "default-size", "focus-widget"];
 export type WindowRow = (typeof WINDOW_ROWS)[number];
 type Handler = (...args: unknown[]) => unknown;
 /** What a port can honestly do. GTK itself has all of it. */
@@ -28,6 +28,8 @@ export interface WindowSubject {
     maximize(window: object): void;
     unmaximize(window: object): void;
     isMaximized(window: object): boolean;
+    getDefaultSize(window: object): [number, number];
+    setDefaultSize(window: object, width: number, height: number): void;
     isVisible(window: object): boolean;
     /** Two widgets inside `window` that can take focus. */
     focusables(window: object): [object, object];

package/lib/types/engine.d.ts

@@ -20,6 +20,16 @@ export interface ForeignClassMeta {
     readonly GTypeName: string;
     readonly Properties?: Readonly<Record<string, ForeignProperty>>;
     readonly Signals?: Readonly<Record<string, ForeignSignal>>;
+    /**
+     * REFUSED, by name, and declared here so the refusal is findable from the call site.
+     *
+     * `Implements` is the one meta key route D cannot carry (ADR 0122 § 4): a foreign-parent class
+     * is registered over a `@nativescript/core` base that is not a GObject, so there is no GType
+     * to add an interface to. A widget that needs `Gio.ListModel` holds one instead of being one —
+     * which is what `Adw.ComboRow:model` does. Ignoring the key would leave a class that says it
+     * implements the interface and does not, which is the silent outcome ADR 0105 refuses.
+     */
+    readonly Implements?: readonly unknown[];
 }
 export interface GObjectEngine {
     /** Names the engine in a diagnostic; `'pure-js'` for the default one. */

package/lib/types/gobject.d.ts

@@ -1,5 +1,5 @@
 import type { SharedTreeNode } from './conformance/shared-trees.js';
-import type { GObjectEngine } from './engine.js';
+import type { ForeignClassMeta, 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. */
@@ -16,6 +16,44 @@ export declare const TYPE_BOOLEAN: GType;
 export declare const TYPE_INT: GType;
 export declare const TYPE_UINT: GType;
 export declare const TYPE_DOUBLE: GType;
+/**
+ * `G_TYPE_OBJECT` — the value type of an object-kind property that takes ANY GObject
+ * ({@link ParamSpec.object}). A property that takes one interface names the interface instead.
+ */
+export declare const TYPE_OBJECT: GType;
+/** What an interface token carries; the token itself is {@link GInterface}. */
+export interface GInterfaceInfo {
+    /** The GIR spelling, as it reads in a refusal and in `items_changed`'s arity message. */
+    readonly name: string;
+    readonly gtype: GType;
+    /** The `vfunc_*` an implementor MUST define. */
+    readonly vfuncs: readonly string[];
+    /** Instance method → the `vfunc_*` it calls through. */
+    readonly methods: Readonly<Record<string, string>>;
+    /** Instance method → the signal it emits, with that signal's arity enforced. */
+    readonly emitters: Readonly<Record<string, string>>;
+    /** The signals the interface brings into the implementor's own signal table. */
+    readonly signals: Readonly<Record<string, readonly GType[]>>;
+}
+/**
+ * One interface of the subset — the value a class puts in `Implements`, and the right-hand side
+ * of `instanceof`.
+ *
+ * It is callable-shaped so `x instanceof ListModel` type-checks like any other `instanceof`;
+ * calling or constructing it throws, because an interface is not a class.
+ */
+export type GInterface = GInterfaceInfo & (abstract new (...args: never[]) => object);
+/**
+ * `Gio.ListModel` — the portable list model's interface, and the whole of the subset's interface
+ * support (ADR 0122 § 2).
+ *
+ * `items-changed` is an ordinary declared signal of every implementor, so an engine that knows
+ * nothing about interfaces registers and emits it like any other; `items_changed()` is the
+ * emitter GIR gives it, down to the arity message real GJS produces for a short call.
+ */
+export declare const ListModel: GInterface;
+/** Whether `instance`'s class chain declares `iface` — what `instanceof ListModel` answers. */
+export declare function implementsInterface(instance: object, iface: GInterface): boolean;
 /**
  * `GObject.Value`, string-only (ADR 0096 Amendment 2). `init` takes `TYPE_STRING`; any other type
  * is refused by name. Real GObject logs a CRITICAL for `get_*`/`set_*` on an uninitialised value and
@@ -38,7 +76,7 @@ export declare const ParamFlags: {
     readonly CONSTRUCT: 4;
     readonly CONSTRUCT_ONLY: 8;
 };
-export type ParamKind = 'boolean' | 'string' | 'int' | 'uint' | 'double';
+export type ParamKind = 'boolean' | 'string' | 'int' | 'uint' | 'double' | 'object';
 export declare class ParamSpec {
     readonly kind: ParamKind;
     readonly name: string;
@@ -47,6 +85,8 @@ export declare class ParamSpec {
     readonly flags: number;
     readonly minimum?: number;
     readonly maximum?: number;
+    /** An object-kind property's value type: {@link TYPE_OBJECT} or the one interface it takes. */
+    readonly valueType?: GType | GInterface;
     private readonly defaultValue;
     private constructor();
     static boolean(name: string, nick: string, blurb: string, flags: number, defaultValue: boolean): ParamSpec;
@@ -54,8 +94,30 @@ export declare class ParamSpec {
     static int(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
     static uint(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
     static double(name: string, nick: string, blurb: string, flags: number, minimum: number, maximum: number, defaultValue: number): ParamSpec;
+    /**
+     * `GObject.ParamSpec.object` — a property that holds another GObject, or `null`.
+     *
+     * `valueType` is {@link TYPE_OBJECT} for "any GObject" or an interface token for a property
+     * that takes only implementors of it (`Adw.ComboRow:model`, which takes a `Gio.ListModel`).
+     * The default is ALWAYS `null`: `g_param_spec_object` has no other, and a write that does
+     * not satisfy `valueType` throws rather than being stored (ADR 0122 § 6).
+     */
+    static object(name: string, nick: string, blurb: string, flags: number, valueType: GType | GInterface): ParamSpec;
     get_default_value(): unknown;
 }
+/**
+ * The type check `g_object_set_property` does before a value reaches the store — the ONE place a
+ * declared property refuses a value, so every object-kind property refuses the same way.
+ *
+ * Only object-kind specs have anything to check: the other five kinds take what GJS's generated
+ * accessors take, which is anything (`_generateAccessors` stores without converting, and the
+ * subset's vectors hold it to that). The messages are the ones real GJS produces for a C object
+ * property, measured on `Gtk.DropDown:model` under GJS 1.88.01 / GTK 4.22.5 — a JS-registered
+ * class is NOT an oracle for them, because GJS's auto-accessors skip the GValue conversion that
+ * raises them. The pointer GJS prints in the "not a subclass" message is left out; nothing can
+ * match it.
+ */
+export declare function checkPropertyValue(spec: ParamSpec, value: unknown): void;
 /** GJS's own symbols, so a class written in the field form (`static [GObject.properties] = …`) registers. */
 export declare const META_SYMBOLS: {
     readonly GTypeName: symbol;
@@ -111,8 +173,10 @@ export interface RegisteredClass {
     readonly typeName: string;
     readonly gtype: GType;
     readonly properties: readonly ParamSpec[];
-    /** Signal name → its parameter types. */
+    /** Signal name → its parameter types; an implemented interface's are merged in. */
     readonly signals: Readonly<Record<string, readonly GType[]>>;
+    /** The interfaces of `Implements`, each one of {@link ACCEPTED_INTERFACES}. */
+    readonly interfaces: readonly GInterface[];
     readonly template?: BlueprintTemplate;
     readonly internalChildren: readonly string[];
     readonly cssName?: string;
@@ -130,6 +194,12 @@ export interface GObjectInstance {
     disconnect(id: number): void;
     emit(signal: string, ...args: unknown[]): void;
 }
+/**
+ * `Implements` on a foreign-parent class: refused by name, on EVERY engine (ADR 0122 § 4). It is
+ * the core's refusal rather than each engine's so that route D says the same thing on the engine
+ * that could never do it and on the one that merely does not.
+ */
+export declare function refuseForeignInterfaces(meta: ForeignClassMeta): 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.
@@ -213,7 +283,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[], engine?: GObjectEngine): void;
+export declare function registerBaseClass(klass: ClassLike, typeName: string, signals: Readonly<Record<string, readonly GType[]>>, properties?: readonly ParamSpec[], interfaces?: readonly GInterface[], 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 {
@@ -241,6 +311,7 @@ export interface GObjectNamespace {
     readonly TYPE_INT: GType;
     readonly TYPE_UINT: GType;
     readonly TYPE_DOUBLE: GType;
+    readonly TYPE_OBJECT: GType;
     readonly GTypeName: symbol;
     readonly GTypeFlags: symbol;
     readonly interfaces: symbol;

package/lib/types/graphene.d.ts

@@ -0,0 +1,27 @@
+/** `Graphene.Point`: a position in two dimensions. */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(props?: Partial<{
+        x: number;
+        y: number;
+    }>);
+    /** `graphene_point_zero`: the origin. */
+    static zero(): Point;
+    /** `graphene_point_init`. */
+    init(x: number, y: number): this;
+}
+/** The slice of a DOM element `compute_point` reads; core has no DOM lib. */
+export interface PointNode {
+    getRootNode(): unknown;
+    getBoundingClientRect(): {
+        readonly left: number;
+        readonly top: number;
+    };
+}
+/**
+ * `gtk_widget_compute_point`: `point` in the coordinates of `source`, as a point in those of
+ * `target`. Two elements have a common ancestor when they are in the same tree, which is the same
+ * root node; a tree that does not reach the other gives `[false, (0, 0)]`, as GTK does.
+ */
+export declare function computePoint(source: PointNode, target: PointNode, point: Point): [boolean, Point];

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

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

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

@@ -1,4 +1,5 @@
 import type { AdwAdjustment, AdwAdjustmentInput } from './adjustment.js';
+import { GObjectObject } from './gobject.js';
 /**
  * What `new Gtk.Adjustment({ … })` takes: the GJS construct bag, which is exactly
  * {@link AdwAdjustmentInput}.
@@ -14,22 +15,32 @@ export type GtkAdjustmentProps = AdwAdjustmentInput;
  * `new GtkAdjustment()` is `ADW_ADJUSTMENT_DEFAULTS` (0…100 step 1), which is the
  * package's own default and NOT GTK's 0…0 step 0 — `adjustment.ts` says why in its header.
  */
-export declare class GtkAdjustment implements AdwAdjustment {
+export declare class GtkAdjustment extends GObjectObject implements AdwAdjustment {
+    constructor(props?: GtkAdjustmentProps | null);
     /** The current value, within {@link adjustmentRange}. */
-    value: number;
+    get value(): number;
+    set value(value: number);
     /** The minimum value. */
-    lower: number;
+    get lower(): number;
+    set lower(lower: number);
     /** The maximum value. */
-    upper: number;
+    get upper(): number;
+    set upper(upper: number);
     /** How far one stepper press moves the value. */
-    stepIncrement: number;
+    get stepIncrement(): number;
+    set stepIncrement(stepIncrement: number);
     /** How far one page press (Page Up/Down) moves the value. */
-    pageIncrement: number;
+    get pageIncrement(): number;
+    set pageIncrement(pageIncrement: number);
     /** The size of the visible page; zero for a scalar value such as a spin row's. */
-    pageSize: number;
-    constructor(props?: GtkAdjustmentProps | null);
+    get pageSize(): number;
+    set pageSize(pageSize: number);
+    /** The six fields, so `JSON.stringify` and a copy see what an object literal would show. */
+    toJSON(): AdwAdjustment;
     /**
-     * Re-establish the invariants around one authored change.
+     * Re-establish the invariants around one authored change, then announce it the way GTK
+     * does: `notify::<property>` for each number that moved, `changed` when the range moved
+     * (or `configure` moved any increment), `value-changed` when the value did.
      *
      * The current six are the BASE, so a field nobody wrote keeps what it held instead of
      * falling back to the package default — the same contract `SpinState.configure` has.

package/lib/types/gtk-string-list.d.ts

@@ -1,72 +1,117 @@
+import { GIR_TYPE, GObjectObject, type GType } from './gobject.js';
+/** `gtk_string_list_find`'s "not found" — `GTK_INVALID_LIST_POSITION`, a `guint` of all ones. */
+export declare const INVALID_LIST_POSITION = 4294967295;
 /**
- * What `new Gtk.StringList({ … })` takes — the GJS spelling of the type's own
- * construct-time properties.
+ * `Gtk.StringObject` — one string, as the `GObject` a `GListModel` is allowed to hand out.
  *
- * `strings` only. The other two `StringList` declares — `item-type` and `n-items` — are
- * `GListModel`'s read-only pair, and a construct bag that accepted them would be offering
- * a write the type does not have.
+ * It exists for the reason it exists in GTK: `g_list_model_get_item` returns a `GObject`, and a
+ * string is not one. Two objects holding the same string are NOT equal (measured), so identity
+ * here means "this entry of this list", never "this text".
+ */
+export declare class GtkStringObject extends GObjectObject {
+    static [GIR_TYPE]: string;
+    constructor(props?: Record<string, unknown> | null);
+    /** `gtk_string_object_new` — the only way to put a string in one. */
+    static new(string: string): GtkStringObject;
+    /**
+     * `Gtk.StringObject:string`.
+     *
+     * `null` on one built without a string: `new Gtk.StringObject().string` is `null`, measured,
+     * and the GIR's non-null typing describes only the items a list hands out.
+     */
+    get string(): string | null;
+    set string(_value: string);
+    /** `gtk_string_object_get_string`. */
+    get_string(): string | null;
+}
+/**
+ * What `new Gtk.StringList({ … })` takes.
+ *
+ * `strings` only, and CONSTRUCT-ONLY, as GTK declares it. The other two the type has —
+ * `item-type` and `n-items` — are `GListModel`'s read-only pair.
  */
 export interface GtkStringListProps {
     /** The strings the list starts with. */
-    strings?: readonly string[] | null;
+    strings?: readonly (string | null)[] | null;
 }
 /**
- * A list of strings under construction — `Gtk.StringList`'s building half over a plain
- * JS array.
+ * `Gtk.StringList` — a `Gio.ListModel` of {@link GtkStringObject}s.
  *
- * `new GtkStringList()` is empty, as `gtk_string_list_new(NULL)` is, and the instance IS
- * the value a `model` property takes.
+ * `new GtkStringList()` is empty, as `gtk_string_list_new(NULL)` is, and the instance is what
+ * every `model` property takes. It is NOT an array and nothing array-shaped reaches it.
  */
-export declare class GtkStringList extends Array<string> {
-    /** See the file header: `map`/`filter`/`slice` must not call this constructor. */
-    static get [Symbol.species](): ArrayConstructor;
+export declare class GtkStringList extends GObjectObject {
+    static [GIR_TYPE]: string;
+    /** Installed by the core from {@link ListModel}; declared here for the type alone. */
+    readonly get_item: (position: number) => GtkStringObject | null;
+    readonly get_item_type: () => GType;
+    readonly get_n_items: () => number;
+    readonly items_changed: (position: number, removed: number, added: number) => void;
     constructor(props?: GtkStringListProps | null);
     /** `gtk_string_list_new`: a list holding `strings`, or an empty one for `null`. */
-    static new(strings: readonly string[] | null): GtkStringList;
+    static new(strings: readonly (string | null)[] | null): GtkStringList;
     /**
-     * `Gtk.StringList:strings`, as the door an attribute reaches. GTK's property is
-     * construct-only, and a NativeScript XML template has no constructor call to pass it
-     * through: `<gtk:StringList strings='["Blue","Teal"]'>` assigns the JSON text to this
-     * member instead, on a list that is still empty. So it REPLACES the contents, as
-     * constructing with `{ strings }` would have filled them.
+     * `Gtk.StringList:strings` as GTK leaves it after construction: unreadable, and unwritable
+     * without saying so.
+     *
+     * Both halves are measured, not chosen. The property is construct-only, so GJS installs a
+     * getter that answers `undefined` and a setter GObject refuses — with a CRITICAL on stderr
+     * and NO exception, leaving the list exactly as it was. Omitting the pair would turn
+     * `list.strings = […]` into a silent own-property write that looks like it worked.
      */
-    get strings(): string[];
-    set strings(value: readonly string[] | string);
+    get strings(): undefined;
+    set strings(_value: readonly string[] | undefined);
+    /** `Gtk.StringList:item-type` — see the file header on why it is `GObject`. */
+    get item_type(): GType;
+    set item_type(_value: GType);
+    get itemType(): GType;
+    set itemType(_value: GType);
+    /** `Gtk.StringList:n-items` — the `ParamSpec`'s reader, and `get_n_items`'s answer. */
+    get n_items(): number;
+    set n_items(_value: number);
+    /** `vfunc_get_item_type` — what the interface's `get_item_type()` calls through to. */
+    vfunc_get_item_type(): GType;
+    /** `vfunc_get_n_items`. */
+    vfunc_get_n_items(): number;
+    /** `vfunc_get_item` — `null` past the end, as `g_list_model_get_item` returns `NULL`. */
+    vfunc_get_item(position: number): GtkStringObject | null;
     /** `gtk_string_list_append`. */
     append(string: string): void;
     /**
      * `gtk_string_list_take` — `append` without the copy.
      *
-     * The copy is what the two differ by in C ("this variant … is convenient for
-     * formatting strings"), and JS strings are immutable, so here the two are one
-     * function. It exists so code ported from GJS keeps working rather than to say
-     * something `append` does not.
+     * The copy is what the two differ by in C ("this variant … is convenient for formatting
+     * strings"), and JS strings are immutable, so here the two are one function. It exists so
+     * code ported from GJS keeps working rather than to say something `append` does not.
      */
     take(string: string): void;
     /** `gtk_string_list_remove` — the string at `position`, which must be in range. */
     remove(position: number): void;
     /**
-     * `gtk_string_list_splice` AND `Array.prototype.splice`, which is the point.
+     * `gtk_string_list_splice(position, n_removals, additions)` — the C signature, all three
+     * arguments, additions as ONE array.
      *
-     * The two say the same thing and pass the additions differently: C takes ONE array of
-     * them, JS takes them as rest arguments. A list whose elements are strings can tell
-     * the two apart with no ambiguity — an element is never an array — so both spellings
-     * work and a `list.splice(1, 2, ['a', 'b'])` ported straight from GJS inserts two
-     * strings instead of silently inserting one array as an element.
-     *
-     * `nRemovals` omitted is `Array.prototype.splice`'s "to the end", which is a different
-     * thing from passing `undefined` — so it is spelled as the count that reaches the end,
-     * which `splice` clamps the same way for a negative `position` as the one-argument form
-     * does.
-     *
-     * Flattened by hand, not `Array.prototype.flatMap` (ES2019): this source is also
-     * type-checked through `@gjsify/gtk-host`'s type-surface gate, whose `tsconfig`s
-     * pin `lib` to ES2017 for reasons of their own (`type-tests/{jsx,react}/tsconfig.json`)
-     * — a method this file alone would happily target ES2020 for is invisible there.
+     * Not `Array.prototype.splice`'s rest-argument form: this class is no longer an array, so the
+     * overload that used to serve both spellings would now be the subset inventing one. Each of
+     * the three refusals below is GJS's own, measured: a short call, a bare string where a strv
+     * belongs, and `undefined` in a slot that takes `null`.
      */
-    splice(position: number, nRemovals?: number, ...additions: readonly (string | readonly string[])[]): string[];
+    splice(position: number, nRemovals: number, additions: readonly (string | null)[] | null): void;
     /** `gtk_string_list_get_string` — `null` past the end, as C returns `NULL`. */
     get_string(position: number): string | null;
-    /** `g_list_model_get_n_items`, which a `GtkStringList` answers with its length. */
-    get_n_items(): number;
+    /**
+     * `gtk_string_list_find` — the POSITION of the first equal string, GTK's meaning of the name,
+     * not `Array.prototype.find`'s. {@link INVALID_LIST_POSITION} when there is none.
+     */
+    find(string: string): number;
+    /**
+     * The one mutation, so the emission rule is written once: `items-changed` first, then
+     * `notify::n-items` and only when the count actually moved, and NEITHER when the splice
+     * removes nothing and adds nothing. All three measured; GTK's own
+     * `gtk_string_list_items_changed` is the same two lines.
+     *
+     * Out of range is a CRITICAL and a no-op, not an exception — `remove` past the end lands on
+     * the same assertion, because `gtk_string_list_remove` IS a splice in C.
+     */
+    private spliceItems;
 }

package/lib/types/index.d.ts

@@ -46,7 +46,7 @@ export { ADW_ADJUSTMENT_DEFAULTS, adjustmentRange, clampAdjustmentValue, normali
 export type { AdwAdjustment, AdwAdjustmentInput, SpinStateChange, SpinStateListener, SpinStateRangeListener, } from './adjustment.js';
 export { GtkAdjustment } from './gtk-adjustment.js';
 export type { GtkAdjustmentProps } from './gtk-adjustment.js';
-export { GtkStringList } from './gtk-string-list.js';
+export { GtkStringList, GtkStringObject, INVALID_LIST_POSITION } from './gtk-string-list.js';
 export type { GtkStringListProps } from './gtk-string-list.js';
 export { ComboState, ExpanderState, ToggleGroupState, keptToggles, toggleIndexOfName } from './rows.js';
 export type { ComboItemsListener, ComboStateChange, ComboStateListener, ExpanderStateListener, ToggleGroupStateChange, ToggleGroupStateListener, } from './rows.js';
@@ -62,6 +62,8 @@ export { iconLookupNames, lookupResourceIcon } from './icon-theme-resources.js';
 export type { IconDirection, ResourceIconMatch, ResourceIconRequest } from './icon-theme-resources.js';
 export { syncDirection, widgetTreeMembers } from './widget-members.js';
 export type { ClipboardHost, GdkClipboard } from './gdk.js';
+export { Point, computePoint } from './graphene.js';
+export type { PointNode } from './graphene.js';
 export { createGLibTimers } from './glib-timers.js';
 export type { GLibTimers, SourceFunc, TimerHost } from './glib-timers.js';
 export { GLibError, DialogError, IOErrorEnum, ResourceError, asGLibError } from './glib-error.js';
@@ -128,16 +130,16 @@ 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, gobjectEngineName, notifyInstance, PURE_JS_ENGINE, registeredClassOf, registerBaseClass, STOP_EMISSION, usePureJsGObjectEngine, type StoppableEmitter, UNLOCKED_VFUNCS, GIR_TYPE, } from './gobject.js';
+export { GObjectObject, ListModel, META_SYMBOLS, ParamFlags, ParamSpec, Value, TYPE_BOOLEAN, TYPE_DOUBLE, TYPE_INT, TYPE_OBJECT, TYPE_STRING, TYPE_UINT, UnsupportedGObjectError, bindProperties, connectInstance, constructRegistered, createClosure, createGObject, disconnectInstance, emitInstance, gobjectEngineName, notifyInstance, PURE_JS_ENGINE, refuseForeignInterfaces, registeredClassOf, registerBaseClass, STOP_EMISSION, usePureJsGObjectEngine, type StoppableEmitter, UNLOCKED_VFUNCS, GIR_TYPE, } from './gobject.js';
 export { ApplicationFlags, ApplicationInhibitFlags, GioApplicationBase, GtkApplicationBase, withGtkApplication, defineWindowApplicationMembers, dispatchAccelerator, isValidApplicationId, } from './application.js';
-export { CloseRequestState, HandledAccumulator, WindowMemberState } from './window-members.js';
-export type { CloseOutcome, CloseRequestSteps, WindowCommon, WindowMemberInit, WindowMemberProperty, } from './window-members.js';
+export { CloseRequestState, HandledAccumulator, WindowMemberState, stepDefaultSize } from './window-members.js';
+export type { CloseOutcome, CloseRequestSteps, DefaultSizeProperty, DefaultSizeStep, WindowCommon, WindowMemberInit, WindowMemberProperty, } from './window-members.js';
 export { AcceleratorMap, ModifierMask, acceleratorName, parseAcceleratorKeyval } from './accelerators.js';
 export type { Accelerator } from './accelerators.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 type { Binding, BindingFlag, BlueprintTemplate, BuiltTemplate, ClassLike, ClassMeta, GInterface, GObjectConstructor, GObjectDoor, GObjectInstance, GObjectNamespace, GType, ParamKind, RegisterClass, RegisteredClass, SignalHandler, SignalMeta, TemplateScope, } from './gobject.js';
 export { engineForTarget, registerGObjectEngine, registeredEngine, resetRegisteredEngine } from './engine.js';
 export type { EngineTarget, ForeignClassMeta, ForeignProperty, ForeignPropertyKind, ForeignSignal, GObjectEngine, } from './engine.js';
 export { MAXUINT32, buildFilenamev, getCurrentDir, getSystemDataDirs } from './glib-paths.js';
@@ -147,5 +149,6 @@ export { unicharIsalpha } from './glib-unichar.js';
 export { GLIB_UNICHAR_UNICODE_VERSION } from './glib-unichar.generated.js';
 export { AppLaunchContext as GioAppLaunchContext, createAppInfo, uriPeekScheme } from './gio-app-info.js';
 export type { GioAppInfo } from './gio-app-info.js';
-export { ColorScheme, StyleManagerBase } from './style-manager.js';
+export { AccentColor, ColorScheme, StyleManagerBase } from './style-manager.js';
+export { RGBA } from './rgba.js';
 export type { StyleSource } from './style-manager.js';