@gjsify/adwaita-core 0.56.0 → 0.58.0

package/lib/types/gobject.d.ts

@@ -0,0 +1,209 @@
+import type { SharedTreeNode } from './conformance/shared-trees.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. */
+export declare class UnsupportedGObjectError extends Error {
+    readonly feature: string;
+    constructor(feature: string, message: string);
+}
+/** An opaque GType token: it names a type and proves nothing else. */
+export interface GType {
+    readonly name: string;
+}
+export declare const TYPE_STRING: GType;
+export declare const TYPE_BOOLEAN: GType;
+export declare const TYPE_INT: GType;
+export declare const TYPE_UINT: GType;
+export declare const TYPE_DOUBLE: GType;
+export declare const ParamFlags: {
+    readonly READABLE: 1;
+    readonly WRITABLE: 2;
+    readonly READWRITE: 3;
+    readonly CONSTRUCT: 4;
+    readonly CONSTRUCT_ONLY: 8;
+};
+export type ParamKind = 'boolean' | 'string' | 'int' | 'uint' | 'double';
+export declare class ParamSpec {
+    readonly kind: ParamKind;
+    readonly name: string;
+    readonly nick: string;
+    readonly blurb: string;
+    readonly flags: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    private readonly defaultValue;
+    private constructor();
+    static boolean(name: string, nick: string, blurb: string, flags: number, defaultValue: boolean): ParamSpec;
+    static string(name: string, nick: string, blurb: string, flags: number, defaultValue: string | null): 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;
+    get_default_value(): unknown;
+}
+/** GJS's own symbols, so a class written in the field form (`static [GObject.properties] = …`) registers. */
+export declare const META_SYMBOLS: {
+    readonly GTypeName: symbol;
+    readonly GTypeFlags: symbol;
+    readonly interfaces: symbol;
+    readonly properties: symbol;
+    readonly signals: symbol;
+    readonly requires: symbol;
+    readonly template: symbol;
+    readonly cssName: symbol;
+    readonly children: symbol;
+    readonly internalChildren: symbol;
+};
+/** What a port's widget tree gives back for one built template. */
+export interface BuiltTemplate {
+    /** The children to attach to the host, in order. */
+    readonly children: readonly object[];
+    /** Every object the template names with an `id`, for `InternalChildren`. */
+    readonly objects: Readonly<Record<string, object>>;
+}
+export type BindingFlag = 'bidirectional' | 'sync-create' | 'invert-boolean';
+export interface Binding {
+    unbind(): void;
+}
+/** What the builder of a port is handed: the instance, its handlers and the binding engine. */
+export interface TemplateScope {
+    /** The template instance — the scope of every handler and the `template` bind source. */
+    readonly instance: object;
+    /** `_createClosure`: looked up on the instance, bound to `options.object` or the instance. */
+    handler(name: string, options?: {
+        object?: object;
+        flags?: readonly string[];
+    }): (...args: unknown[]) => unknown;
+    bind(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags?: readonly BindingFlag[]): Binding;
+}
+/** The one thing a port implements over its widget model (ADR 0096 § 1). */
+export interface GObjectDoor {
+    readonly name: string;
+    /** Dispatches the named event on a widget that is not the core's to dispatch. */
+    dispatch(target: object, event: string, args: readonly unknown[]): void;
+    /** Listens for it; the handler is called `(target, ...args)`. Returns the disconnect. */
+    listen(target: object, event: string, handler: (...args: unknown[]) => unknown): () => void;
+    /** Creates the widgets of a template, wiring signals and binds through `scope`. */
+    createFromTree(tree: BlueprintTemplate, scope: TemplateScope, host: object): BuiltTemplate;
+    /** Gives the built children to the host. A port may defer the attach to its own lifecycle. */
+    attach(host: object, built: BuiltTemplate): void;
+    /** A class was registered: the port defines its element and its `$GTypeName` template entry. */
+    register(klass: ClassLike, info: RegisteredClass): void;
+}
+export type ClassLike = abstract new (...args: never[]) => object;
+export interface RegisteredClass {
+    readonly klass: ClassLike;
+    readonly typeName: string;
+    readonly gtype: GType;
+    readonly properties: readonly ParamSpec[];
+    /** Signal name → its parameter types. */
+    readonly signals: Readonly<Record<string, readonly GType[]>>;
+    readonly template?: BlueprintTemplate;
+    readonly internalChildren: readonly string[];
+    readonly cssName?: string;
+    readonly door: GObjectDoor;
+}
+export declare function registeredClassOf(klass: object): RegisteredClass | undefined;
+export type SignalHandler = (emitter: GObjectInstance, ...args: unknown[]) => unknown;
+/** The instance surface of a registered class (ADR 0096 § 2, "instance API" row). */
+export interface GObjectInstance {
+    [key: string]: unknown;
+    notify(name: string): void;
+    connect(signal: string, handler: SignalHandler): number;
+    disconnect(id: number): void;
+    emit(signal: string, ...args: unknown[]): void;
+}
+/**
+ * `GObject.signal_stop_emission_by_name`: stops the innermost emission in progress of the signal on the
+ * instance, so the handlers after the current one do not run. With none in progress GLib warns and
+ * does nothing (`g_signal_stop_emission`: "no emission of signal ... to stop").
+ */
+export declare function stopEmissionByName(instance: GObjectInstance, detailedSignal: string): void;
+export declare function connectInstance(instance: GObjectInstance, signal: string, handler: SignalHandler): number;
+export declare function disconnectInstance(instance: GObjectInstance, id: number): void;
+export declare function emitInstance(instance: GObjectInstance, signal: string, ...args: unknown[]): void;
+export declare function notifyInstance(instance: GObjectInstance, name: string): void;
+/**
+ * `g_object_bind_property` for the three flags the template builders need. The target follows the
+ * source on every `notify::<source property>`; `bidirectional` makes the source follow the target
+ * back, `invert-boolean` negates what crosses, `sync-create` transfers once at bind time.
+ */
+export declare function bindProperties(source: GObjectInstance, sourceProperty: string, target: GObjectInstance, targetProperty: string, flags?: readonly BindingFlag[]): Binding;
+export declare function createClosure(thisArg: object, handlerName: string, swapped: boolean, connectObject?: object): (...args: unknown[]) => unknown;
+/**
+ * Runs ADR 0096 § 3 steps 4–5 for a registered instance, in GJS's order: every template of the
+ * class chain is built first (base first), then the construct properties are set, and only then
+ * is each `InternalChildren` id installed as `this._<id>`. So `this._x` is `undefined` inside a
+ * property setter that runs during construction and defined once `super(params)` returns.
+ *
+ * Returns the params that are not declared properties, for the port's own construct bag.
+ */
+export declare function constructRegistered(instance: object, params?: Readonly<Record<string, unknown>>): Record<string, unknown>;
+export interface SignalMeta {
+    param_types?: readonly GType[];
+    [refused: string]: unknown;
+}
+export interface ClassMeta {
+    GTypeName?: string;
+    Template?: unknown;
+    InternalChildren?: readonly string[];
+    Properties?: Readonly<Record<string, ParamSpec>>;
+    Signals?: Readonly<Record<string, SignalMeta>>;
+    CssName?: string;
+    [refused: string]: unknown;
+}
+export interface RegisterClass {
+    <T extends ClassLike>(meta: ClassMeta, klass: T): T;
+    <T extends ClassLike>(klass: T): T;
+}
+/** A core class declares the GIR type its `vfunc_*` are listed under in {@link UNLOCKED_VFUNCS}. */
+export declare const GIR_TYPE: unique symbol;
+/**
+ * The `vfunc_*` a registered class may override (ADR 0098 § 1a), keyed by the GIR class that declares
+ * them. Every other `vfunc_*` is refused by name. An entry needs a vector of `APPLICATION_VECTORS`
+ * (`unlocks`) that holds on real GJS; `application.spec.ts` fails an entry without one.
+ */
+export declare const UNLOCKED_VFUNCS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Registers a core class that is no widget and has no template (`Gio.Application`), so its signals
+ * 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 type GObjectConstructor = new (params?: Record<string, unknown>) => GObjectInstance;
+/** `GObject.Object` for a registered class with no widget model beneath it. */
+export declare class GObjectObject {
+    [key: string]: unknown;
+    constructor(params?: Record<string, unknown>);
+    notify(name: string): void;
+    connect(signal: string, handler: SignalHandler): number;
+    disconnect(id: number): void;
+    emit(signal: string, ...args: unknown[]): void;
+}
+export interface GObjectNamespace {
+    readonly Object: GObjectConstructor;
+    readonly registerClass: RegisterClass;
+    readonly ParamSpec: typeof ParamSpec;
+    readonly ParamFlags: typeof ParamFlags;
+    readonly TYPE_STRING: GType;
+    readonly TYPE_BOOLEAN: GType;
+    readonly TYPE_INT: GType;
+    readonly TYPE_UINT: GType;
+    readonly TYPE_DOUBLE: GType;
+    readonly GTypeName: symbol;
+    readonly GTypeFlags: symbol;
+    readonly interfaces: symbol;
+    readonly properties: symbol;
+    readonly signals: symbol;
+    readonly requires: symbol;
+    readonly __gtkTemplate__: symbol;
+    readonly __gtkCssName__: symbol;
+    readonly __gtkChildren__: symbol;
+    readonly __gtkInternalChildren__: symbol;
+    type_ensure(gtype: GType): void;
+    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}.
+ */
+export declare function createGObject(door: GObjectDoor): GObjectNamespace;

package/lib/types/gobject.gjs.spec.d.ts

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

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

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

package/lib/types/index.d.ts

@@ -50,6 +50,8 @@ export type { BoxOrientation } from './box.js';
 export { DEFAULT_LABEL_ELLIPSIZE, DEFAULT_LABEL_LINES, DEFAULT_LABEL_MAX_WIDTH_CHARS, DEFAULT_LABEL_WIDTH_CHARS, DEFAULT_LABEL_WRAP_MODE, DEFAULT_LABEL_XALIGN, DEFAULT_LABEL_YALIGN, LABEL_ELLIPSIZE_MODES, LABEL_JUSTIFICATIONS, LABEL_WRAP_MODES, labelDisplayText, labelEffectiveLines, labelEllipsizeOverflowValue, labelMarkupIsUnparseable, labelWidthCharsExtent, labelYalignAlignItems, normalizeLabelEllipsize, normalizeLabelJustify, normalizeLabelLines, normalizeLabelMaxWidthChars, normalizeLabelWidthChars, normalizeLabelWrapMode, normalizeLabelXalign, normalizeLabelYalign, } from './label.js';
 export type { LabelAlignItems, LabelEllipsizeMode, LabelJustification, LabelWidthCharsExtent, LabelWrapMode, } from './label.js';
 export { glibClamp, gStrStrip, stringIsNotEmpty } from './glib.js';
+export { createGLibTimers } from './glib-timers.js';
+export type { GLibTimers, SourceFunc, TimerHost } from './glib-timers.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';
@@ -72,6 +74,11 @@ export type { AdwPackType, AdwTextDirection, NavigationActionInput, NavigationAc
 export { DEFAULT_DROPDOWN_TOOLTIP, SPLIT_BUTTON_DISABLED_OPACITY, SplitButtonState, isSplitButtonDirection, menuButtonArrowIcon, menuButtonPopupDirection, resolveDropdownTooltip, splitButtonArrowIcon, splitButtonPopupDirection, splitButtonRootState, splitButtonStyleClasses, } from './split-button.js';
 export type { AdwArrowIcon, SplitButtonChange, SplitButtonContentMode, SplitButtonDirection, SplitButtonHalfState, SplitButtonListener, SplitButtonProperty, SplitButtonStyleClass, } from './split-button.js';
 export { GioMenu, GioMenuItem } from './gio-menu.js';
+export { activateMenuItem, menuActionsFor } from './menu-actions.js';
+export { assertPopupMenuPlan, planPopupMenu } from './popup-menu-plan.js';
+export type { PopupMenuEntryPlan, PopupMenuGroupPlan, PopupMenuItemPlan, PopupMenuLevelPlan, PopupMenuPlan, PopupMenuRefusal, PopupMenuSubmenuPlan, } from './popup-menu-plan.js';
+export { menuAssignments } from './menu-tree.js';
+export type { MenuTreeNode } from './menu-tree.js';
 export { ADW_MENU_SURFACE_NATIVESCRIPT, ADW_MENU_SURFACE_WEB, assertMenuRenderable, flattenMenu, menuItemAt, menuNodeAt, menuRefusals, normalizeMenuModel, parseDetailedAction, parseMenuModel, resolveMenuItemState, } from './menu.js';
 export type { AdwDetailedAction, AdwMenuAction, AdwMenuActions, AdwMenuDisplayHint, AdwMenuEntryInput, AdwMenuFlatRow, AdwMenuHiddenWhen, AdwMenuInput, AdwMenuItem, AdwMenuItemInput, AdwMenuItemRole, AdwMenuItemState, AdwMenuModel, AdwMenuNode, AdwMenuPath, AdwMenuRefusal, AdwMenuSection, AdwMenuSectionInput, AdwMenuSubmenu, AdwMenuSubmenuInput, AdwMenuSurface, AdwMenuTextDirection, } from './menu.js';
 export { DEFAULT_INDICATOR_DESCRIPTION_STRINGS, INLINE_VIEW_SWITCHER_DISPLAY_MODES, VIEW_SWITCHER_BADGE_LIMIT, VIEW_SWITCHER_DRAG_SWITCH_DELAY, VIEW_SWITCHER_FALLBACK_ICON, VIEW_SWITCHER_NO_SELECTION, VIEW_SWITCHER_POLICIES, ViewSwitcherBarState, ViewSwitcherDragSwitch, ViewSwitcherState, buildInlineToggles, buildViewSwitcherButtons, createViewSwitcherPage, inlineToggleTooltip, isInlineViewSwitcherDisplayMode, isViewSwitcherButtonVisible, isViewSwitcherPolicy, pageIndexForToggle, shouldRevealViewSwitcherBar, stripMnemonic, toggleIndexForPage, viewSwitcherBadgeLabel, viewSwitcherButtonOrientation, viewSwitcherIconName, viewSwitcherIndicatorDescription, viewSwitcherLabel, viewSwitcherPageFromStackPage, viewSwitcherPagesFromStack, viewSwitcherSidebarSections, } from './view-switcher.js';
@@ -101,3 +108,12 @@ 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, TYPE_BOOLEAN, TYPE_DOUBLE, TYPE_INT, TYPE_STRING, TYPE_UINT, UnsupportedGObjectError, bindProperties, connectInstance, constructRegistered, createClosure, createGObject, disconnectInstance, emitInstance, notifyInstance, registeredClassOf, registerBaseClass, 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 { MAXUINT32, buildFilenamev, getCurrentDir, getSystemDataDirs } from './glib-paths.js';
+export { StyleManagerBase } from './style-manager.js';
+export type { StyleSource } from './style-manager.js';

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

@@ -0,0 +1,16 @@
+import type { AdwMenuActions, AdwMenuModel, AdwMenuItem } from './menu.js';
+type Parent = (node: object) => object | null | undefined;
+/**
+ * The actions the model's items name, as `widget` resolves them. An action the walk does not find,
+ * because no group has its prefix or the group lacks it, is left out, which is "missing" and makes
+ * the item insensitive. That is GTK's answer, measured on GJS (`menu-actions.gjs.spec.ts`), and it
+ * overrules ADR 0097 § 3's "no group dims nothing": an application that dispatches an action
+ * itself declares it, or passes `actions` to say what it knows.
+ */
+export declare function menuActionsFor(model: AdwMenuModel, widget: object, parent: Parent): AdwMenuActions;
+/**
+ * Fire the action an item names, the way `GtkMenuTrackerItem` does on activation. A target is
+ * passed as its text: `GLib.Variant` is outside the subset until stage 3.
+ */
+export declare function activateMenuItem(item: AdwMenuItem, widget: object, parent: Parent): boolean;
+export {};

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

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

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

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

package/lib/types/menu-tree.d.ts

@@ -0,0 +1,12 @@
+import type { AdwMenuModel } from './menu.js';
+/** The slice of a tree node this reads. */
+export interface MenuTreeNode {
+    readonly tag: string;
+    readonly props?: Readonly<Record<string, string | number | boolean>>;
+    readonly menuModels?: Readonly<Record<string, readonly unknown[]>>;
+}
+/**
+ * The menus a node assigns, as `[property, model]`: the root menu `menu-model: id` names, and each
+ * model written at a property. An id with no root menu is refused by name.
+ */
+export declare function menuAssignments(node: MenuTreeNode, menus: Readonly<Record<string, readonly unknown[]>> | undefined): Array<[string, AdwMenuModel]>;

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

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

package/lib/types/popup-menu-plan.d.ts

@@ -0,0 +1,47 @@
+import type { AdwMenuActions, AdwMenuModel, AdwMenuPath } from './menu.js';
+/** An item of the plan; `path` maps a tap back to the model. */
+export interface PopupMenuItemPlan {
+    readonly kind: 'item';
+    readonly path: AdwMenuPath;
+    readonly title: string;
+    /** Shown disabled, not omitted: the dimmed row is the platform's own idiom (0097 § 2). */
+    readonly enabled: boolean;
+    /** CHECK items set it themselves; a RADIO item takes it from its exclusive group. */
+    readonly checkable: boolean;
+    readonly checked: boolean;
+    readonly role: 'normal' | 'check' | 'radio';
+    /** The action name without its target: the identity of a radio run. */
+    readonly action?: string;
+}
+/** A submenu: `Menu.addSubMenu`, whose items are a level of their own. */
+export interface PopupMenuSubmenuPlan {
+    readonly kind: 'submenu';
+    readonly path: AdwMenuPath;
+    readonly title: string;
+    readonly level: PopupMenuLevelPlan;
+}
+export type PopupMenuEntryPlan = PopupMenuItemPlan | PopupMenuSubmenuPlan;
+/** One `groupId`: a section, or the run of items outside any section. */
+export interface PopupMenuGroupPlan {
+    /** `exclusive` is `setGroupCheckable(group, true, true)`; the flag is per group on Android. */
+    readonly checkable: 'none' | 'exclusive';
+    readonly entries: readonly PopupMenuEntryPlan[];
+}
+export interface PopupMenuLevelPlan {
+    readonly groups: readonly PopupMenuGroupPlan[];
+}
+/** What `PopupMenu` cannot express, by the name the diagnostic uses. */
+export interface PopupMenuRefusal {
+    readonly what: 'custom' | 'section-label' | 'mixed-radio-section';
+    /** The item for `custom`, the section (or the submenu / root holding the loose items) otherwise. */
+    readonly path: AdwMenuPath;
+    readonly message: string;
+}
+export interface PopupMenuPlan {
+    readonly level: PopupMenuLevelPlan;
+    readonly refusals: readonly PopupMenuRefusal[];
+}
+/** Lower `model` for `PopupMenu`. `actions` is what {@link resolveMenuItemState} reads. */
+export declare function planPopupMenu(model: AdwMenuModel, actions?: AdwMenuActions): PopupMenuPlan;
+/** Throw naming every refusal, as `assertMenuRenderable` does for the sheet. */
+export declare function assertPopupMenuPlan(plan: PopupMenuPlan): void;

package/lib/types/popup-menu-plan.spec.d.ts

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

package/lib/types/simple-action-group.gjs.spec.d.ts

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

package/lib/types/simple-action-group.spec.d.ts

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

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

@@ -0,0 +1,14 @@
+import { GIR_TYPE, GObjectObject } from './gobject.js';
+/** Where a platform reads "is the interface dark" and hears it change. */
+export interface StyleSource {
+    dark(): boolean;
+    /** Calls `changed` whenever `dark()` may have changed; returns the unsubscribe. */
+    subscribe(changed: () => void): () => void;
+}
+export declare class StyleManagerBase extends GObjectObject {
+    static [GIR_TYPE]: string;
+    static source: StyleSource | undefined;
+    static get_default(): StyleManagerBase;
+    get dark(): boolean;
+    get_dark(): boolean;
+}

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/adwaita-core",
-    "version": "0.56.0",
+    "version": "0.58.0",
     "description": "Headless Adwaita widget behavior (breakpoint condition grammar + apply/unapply state machine, color-scheme observable, avatar derivation) shared by the web and NativeScript Adwaita renderers — pure TS, no platform imports",
     "type": "module",
     "module": "lib/esm/index.js",
@@ -58,8 +58,8 @@
         "headless"
     ],
     "devDependencies": {
-        "@gjsify/cli": "^0.56.0",
-        "@gjsify/unit": "^0.56.0",
+        "@gjsify/cli": "^0.58.0",
+        "@gjsify/unit": "^0.58.0",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },