@gtkx/react 1.3.0 → 1.4.0

package/src/element-behaviors.ts

@@ -34,7 +34,13 @@ import {
     registerElements,
 } from "./reconciler/registry.js";
 import { applyWrite } from "./reconciler/signals.js";
-import { applyStyle, styleClass } from "./reconciler/style.js";
+import { applyStyle, CSS_CLASSES_PROP, styleClass } from "./reconciler/style.js";
+
+type SelectedIndexState = { desired: number | undefined; isScheduled: boolean; disconnect: (() => void) | null };
+
+const SELECTED_INDEX_PROP = "selectedIndex";
+const SELECTION_SIGNAL = "selected-rows-changed";
+const NO_SELECTION = -1;
 
 const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
     ...forTypes(SINGLE_CHILD_TYPES, {
@@ -114,6 +120,7 @@ const BUILTIN_BEHAVIORS: Record<string, ElementConfig<never>> = {
             wrappingIndexedSlot(Gtk.ListBoxRow, (row, inner) => {
                 row.setChild(inner);
             }),
+            selectedIndexBehavior(),
         ],
     },
     GtkFlowBox: {
@@ -430,8 +437,8 @@ const didWriteCssClasses = (widget: Gtk.Widget, prev: Props, next: Props, classN
         return false;
     }
 
-    applyWrite(() => {
-        Reflect.set(widget, "cssClasses", withStyleClass(next.cssClasses, className));
+    applyWrite(CSS_CLASSES_PROP, () => {
+        Reflect.set(widget, CSS_CLASSES_PROP, withStyleClass(next.cssClasses, className));
     });
 
     return true;
@@ -460,6 +467,118 @@ function styleBehavior(): ElementBehavior<Gtk.Widget> {
     return { update: updateStyle };
 }
 
+function selectedRowIndex(box: Gtk.ListBox): number {
+    return box.getSelectedRow()?.getIndex() ?? NO_SELECTION;
+}
+
+function selectedIndexError(value: number): Error {
+    return new Error(
+        "The 'selectedIndex' of a <GtkListBox> must be a whole number, or -1 to select no row; " +
+        `received ${String(value)}.`,
+    );
+}
+
+function desiredIndex(value: unknown): number | undefined {
+    if (value === null) {
+        return NO_SELECTION;
+    }
+
+    if (typeof value !== "number") {
+        return undefined;
+    }
+
+    if (!Number.isSafeInteger(value)) {
+        throw selectedIndexError(value);
+    }
+
+    return value;
+}
+
+function selectRowAt(box: Gtk.ListBox, row: Gtk.ListBoxRow): void {
+    applyWrite(SELECTED_INDEX_PROP, () => {
+        box.selectRow(row);
+    });
+}
+
+function clearSelection(box: Gtk.ListBox): void {
+    applyWrite(SELECTED_INDEX_PROP, () => {
+        box.unselectAll();
+    });
+}
+
+function applySelectedIndex(box: Gtk.ListBox, state: SelectedIndexState): void {
+    const { desired } = state;
+
+    if (desired === undefined || selectedRowIndex(box) === desired) {
+        return;
+    }
+
+    if (desired < 0) {
+        clearSelection(box);
+
+        return;
+    }
+
+    const row = box.getRowAtIndex(desired);
+
+    if (row !== null) {
+        selectRowAt(box, row);
+    }
+}
+
+function scheduleSelectedIndex(box: Gtk.ListBox, state: SelectedIndexState): void {
+    if (state.isScheduled) {
+        return;
+    }
+
+    state.isScheduled = true;
+
+    queueMicrotask(() => {
+        state.isScheduled = false;
+
+        if (state.disconnect !== null) {
+            applySelectedIndex(box, state);
+        }
+    });
+}
+
+function watchSelectionDrift(box: Gtk.ListBox, state: SelectedIndexState): void {
+    if (state.disconnect !== null) {
+        return;
+    }
+
+    const handler = (): undefined => {
+        scheduleSelectedIndex(box, state);
+    };
+
+    box.on(SELECTION_SIGNAL, handler);
+
+    state.disconnect = (): void => {
+        box.off(SELECTION_SIGNAL, handler);
+    };
+}
+
+function selectedIndexBehavior(): ElementBehavior<Gtk.ListBox> {
+    return {
+        deferred: [SELECTED_INDEX_PROP],
+        initialize: (): SelectedIndexState => ({ desired: undefined, isScheduled: false, disconnect: null }),
+        update: (_box, _prev, next, context) => {
+            (context as SelectedIndexState).desired = desiredIndex(next[SELECTED_INDEX_PROP]);
+
+            return [SELECTED_INDEX_PROP];
+        },
+        flush: (box, context) => {
+            applySelectedIndex(box, context as SelectedIndexState);
+            watchSelectionDrift(box, context as SelectedIndexState);
+        },
+        teardown: (_box, context) => {
+            const state = context as SelectedIndexState;
+            state.disconnect?.();
+            state.disconnect = null;
+        },
+    };
+}
+
 const addMainOption = (application: Gtk.Application, option: MainOption): void => {
     application.addMainOption(
         option.longName,

package/src/element-config.ts

@@ -82,7 +82,7 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
         props: internal("ChildrenProps"),
     },
     GtkListBox: {
-        props: internal("ChildrenProps"),
+        props: internal("GtkListBoxProps"),
     },
     GtkFlowBox: {
         props: internal("ChildrenProps"),

package/src/hooks/use-bind-setting.ts

@@ -3,6 +3,7 @@ import * as Gio from "@gtkx/gi/gio";
 import { kebabCase } from "@gtkx/utils";
 import { useLayoutEffect } from "react";
 import type { SettingsSchema, SettingsSchemaKeys } from "../utils/settings.js";
+import { getPropertyName } from "../reconciler/metadata.js";
 import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 import { useSettings } from "./use-setting.js";
 
@@ -32,7 +33,6 @@ function useBindSetting<K extends SettingsSchemaKeys>({
     flags = Gio.SettingsBindFlags.DEFAULT,
 }: UseBindSettingOptions<K>): void {
     const settings = useSettings(schema);
-    const propertyName = kebabCase(property);
 
     useLayoutEffect(() => {
         const resolved = resolveRefProp(object);
@@ -41,12 +41,13 @@ function useBindSetting<K extends SettingsSchemaKeys>({
             return;
         }
 
+        const propertyName = getPropertyName(resolved, property) ?? kebabCase(property);
         settings.bind(key, resolved, propertyName, flags);
 
         return () => {
             Gio.Settings.unbind(resolved, propertyName);
         };
-    }, [settings, key, object, propertyName, flags]);
+    }, [settings, key, object, property, flags]);
 }
 
 export { useBindSetting };

package/src/hooks/use-property.ts

@@ -1,6 +1,7 @@
 import type * as GObject from "@gtkx/gi/gobject";
 import { kebabCase } from "@gtkx/utils";
-import type { RefProp } from "../utils/ref-prop.js";
+import { getPropertyName } from "../reconciler/metadata.js";
+import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 import { useObjectValue } from "./use-object-value.js";
 
 /** The property map `T` declares, from camelCase property name to value type. */
@@ -18,7 +19,10 @@ function useProperty<T extends GObject.Object, P extends PropertyName<T>>(
     object: RefProp<T>,
     propertyName: P & string,
 ): T[P] | undefined {
-    return useObjectValue(object, `notify::${kebabCase(propertyName)}`, (obj) => obj?.[propertyName]);
+    const resolved = resolveRefProp(object);
+    const name = (resolved === null ? undefined : getPropertyName(resolved, propertyName)) ?? kebabCase(propertyName);
+
+    return useObjectValue(object, `notify::${name}`, (obj) => obj?.[propertyName]);
 }
 
 export { useProperty };

package/src/prop-types.ts

@@ -246,6 +246,15 @@ type GtkScaleProps = {
     marks?: ScaleMark[] | null | undefined;
 };
 
+/** Props of a `Gtk.ListBox` element. */
+type GtkListBoxProps = {
+    /**
+     * Index of the row to select; `-1` or `null` selects none. Applied once the row exists, and
+     * re-applied whenever the box's own selection drifts from it. Left alone while the prop is absent.
+     */
+    selectedIndex?: number | null | undefined;
+} & ChildrenProps;
+
 /** Props of a `Gtk.Calendar` element. */
 type GtkCalendarProps = {
     /** Days of the shown month drawn as marked, cleared and re-marked whenever the list changes. */
@@ -324,6 +333,7 @@ export {
     type GtkConstraintLayoutProps,
     type GtkHeaderBarProps,
     type GtkScaleProps,
+    type GtkListBoxProps,
     type GtkCalendarProps,
     type GtkLevelBarProps,
     type GtkSizeGroupProps,

package/src/reconciler/apply-props.ts

@@ -1,11 +1,11 @@
-import type * as GObject from "@gtkx/gi/gobject";
 import type { SignalHandler } from "@gtkx/runtime";
+import * as GObject from "@gtkx/gi/gobject";
 import * as Gtk from "@gtkx/gi/gtk";
-import { coerceObjectProperty } from "@gtkx/runtime";
-import { drain, isDeepEqual, kebabCase } from "@gtkx/utils";
+import { coerceObjectProperty, getInstanceType, signalForHandlerName, TYPE_INVALID } from "@gtkx/runtime";
+import { drain, isDeepEqual, kebabCase, lowerFirst, unsanitizeIdentifier } from "@gtkx/utils";
 import type { ElementBehavior, Props } from "./registry.js";
 import { applyAccessibleProps, isAccessibleProp } from "../utils/accessible-props.js";
-import { type TypeInfo, typeInfoFor } from "./metadata.js";
+import { getPropertyName, hasProperty, type TypeInfo, typeInfoFor } from "./metadata.js";
 import { type ElementNode, getOrCreateContext, type SignalTarget } from "./node.js";
 import { applyWrite, connectHandler, disconnectHandler } from "./signals.js";
 import { bufferText, hasSameText, isContentPaintableProp, markTextDirty, TEXT_PROP } from "./text.js";
@@ -16,29 +16,53 @@ type PropChange = { prev: Props; next: Props };
 
 const REACT_RESERVED_PROPS = new Set(["children", "ref", "key"]);
 const NOTIFY_PREFIX = "onNotify";
-const HANDLER_PREFIX = "on";
 const HANDLER_NAME = /^on[A-Z]/;
 const flushDirty: Set<ElementNode> = new Set();
 const accessibleDirty: Map<ElementNode, Props> = new Map();
-const mapWatched: WeakSet<ElementNode> = new WeakSet();
+const mapWatched: WeakMap<ElementNode, () => void> = new WeakMap();
 const pendingMap: Set<ElementNode> = new Set();
 
 const isHandlerName = (name: string): boolean => HANDLER_NAME.test(name);
+const notifiedAccessor = (name: string): string => lowerFirst(name.slice(NOTIFY_PREFIX.length));
 
-const signalForProp = (info: TypeInfo, name: string): string => {
+const unknownSignalError = (typeName: string, name: string): Error =>
+    new Error(
+        `The handler prop '${name}' of <${typeName}> names no signal ${typeName} carries. Name a ` +
+        `signal the element carries, or declare the one '${name}' stands for on ${typeName} when ` +
+        "its class is registered.",
+    );
+
+const lookedUpSignal = (target: SignalTarget, name: string): string => {
+    const type = getInstanceType(target.object);
+    const signal = type === TYPE_INVALID ? undefined : signalForHandlerName(type, name);
+
+    if (signal === undefined) {
+        throw unknownSignalError(target.typeName, name);
+    }
+
+    return signal;
+};
+
+const signalForProp = (target: SignalTarget, info: TypeInfo, name: string): string => {
     if (name === NOTIFY_PREFIX) {
         return "notify";
     }
 
     if (name.startsWith(NOTIFY_PREFIX) && name.length > NOTIFY_PREFIX.length) {
-        return `notify::${kebabCase(name.slice(NOTIFY_PREFIX.length))}`;
+        const accessor = notifiedAccessor(name);
+        const property = getPropertyName(target.object, accessor) ?? unsanitizeIdentifier(kebabCase(accessor));
+
+        return `notify::${property}`;
     }
 
-    return info.signals[name] ?? kebabCase(name.slice(HANDLER_PREFIX.length));
+    return info.signals[name] ?? lookedUpSignal(target, name);
 };
 
 const isReservedName = (name: string, info: TypeInfo): boolean =>
-    REACT_RESERVED_PROPS.has(name) || isHandlerName(name) || isAccessibleProp(name) || info.constructOnly.has(name);
+    REACT_RESERVED_PROPS.has(name) ||
+    (isHandlerName(name) && !hasProperty(info, name)) ||
+    (isAccessibleProp(name) && !hasProperty(info, name)) ||
+    info.constructOnly.has(name);
 
 const isSkippedValueName = (name: string, info: TypeInfo, consumed: Set<string>): boolean =>
     isReservedName(name, info) || consumed.has(name);
@@ -48,7 +72,7 @@ const writeValue = (object: GObject.Object, name: string, value: unknown): void
         return;
     }
 
-    applyWrite(() => {
+    applyWrite(name, () => {
         Reflect.set(object, name, coerceObjectProperty(object, name, value));
     });
 };
@@ -72,7 +96,7 @@ const applyBufferText = (buffer: Gtk.TextBuffer, text: string): void => {
         return;
     }
 
-    applyWrite(() => {
+    applyWrite(TEXT_PROP, () => {
         buffer.beginIrreversibleAction();
         buffer.setText(text, -1);
         buffer.endIrreversibleAction();
@@ -191,24 +215,26 @@ const restoreActionableSensitivity = (node: ElementNode, info: TypeInfo, prev: P
     const desired = "sensitive" in next ? next.sensitive : info.defaults.sensitive;
 
     if (typeof desired === "boolean") {
-        applyWrite(() => {
+        applyWrite("sensitive", () => {
             Reflect.set(node.object, "sensitive", desired);
         });
     }
 };
 
-const applyHandlers = (target: SignalTarget, info: TypeInfo, prev: Props, next: Props): void => {
-    eachChangedName(prev, next, (name) => {
-        if (!isHandlerName(name)) {
-            return;
-        }
+const applyHandler = (target: SignalTarget, info: TypeInfo, name: string, next: Props): void => {
+    const value = next[name];
 
-        const value = next[name];
+    if (typeof value === "function") {
+        connectHandler(target, name, signalForProp(target, info, name), value as SignalHandler);
+    } else {
+        disconnectHandler(target, name);
+    }
+};
 
-        if (typeof value === "function") {
-            connectHandler(target, name, signalForProp(info, name), value as SignalHandler);
-        } else {
-            disconnectHandler(target, name);
+const applyHandlers = (target: SignalTarget, info: TypeInfo, prev: Props, next: Props): void => {
+    eachChangedName(prev, next, (name) => {
+        if (isHandlerName(name) && !hasProperty(info, name)) {
+            applyHandler(target, info, name, next);
         }
     });
 };
@@ -231,6 +257,15 @@ const flushBehaviors = (): void => {
     });
 };
 
+const teardownBehaviors = (node: ElementNode): void => {
+    flushDirty.delete(node);
+    unwatchMap(node);
+
+    for (const [behavior, context] of node.contexts) {
+        behavior.teardown?.(node.object, context);
+    }
+};
+
 const applyAccessible = (object: GObject.Object, prev: Props | null, next: Props): void => {
     if (object instanceof Gtk.Accessible) {
         applyAccessibleProps(object, prev, next);
@@ -260,14 +295,25 @@ const watchMap = (node: ElementNode): void => {
         return;
     }
 
-    mapWatched.add(node);
-
-    object.connect("map", () => {
+    const onMapped = (): undefined => {
         pendingMap.add(node);
         setTimeout(settleAccessible, 0);
+    };
+
+    object.on("map", onMapped);
+
+    mapWatched.set(node, () => {
+        object.off("map", onMapped);
     });
 };
 
+const unwatchMap = (node: ElementNode): void => {
+    mapWatched.get(node)?.();
+    mapWatched.delete(node);
+    pendingMap.delete(node);
+    accessibleDirty.delete(node);
+};
+
 const settleAccessible = (): void => {
     drain(pendingMap, (node) => {
         if (node.object instanceof Gtk.Widget && node.object.getMapped()) {
@@ -319,6 +365,7 @@ export {
     flushAccessible,
     settleAccessible,
     flushBehaviors,
+    teardownBehaviors,
     applyElementProps,
     applyAdoptedProps,
     assertPropsCanChange,

package/src/reconciler/behaviors.ts

@@ -10,8 +10,9 @@ import {
     typeFromName,
     typeIsA,
 } from "@gtkx/runtime";
-import { getOrInsert, isDeepEqual, structuredClone } from "@gtkx/utils";
+import { getOrInsert, isDeepEqual, kebabCase, structuredClone, unsanitizeIdentifier } from "@gtkx/utils";
 import type { DetachInfo, ElementBehavior, PlaceInfo, Props } from "./registry.js";
+import { getPropertyName } from "./metadata.js";
 import { applyWrite } from "./signals.js";
 import { hasSameText } from "./text.js";
 
@@ -32,7 +33,7 @@ type ListHooks<P extends GObject.Object, I, H> = {
 
 type ListEntry = { item: unknown; handle: unknown };
 type ListState = { snapshot: unknown[]; entries: ListEntry[] };
-type DeferredState = { desired: unknown; isPresent: boolean; applied: unknown };
+type DeferredState = { desired: unknown; isPresent: boolean; isScheduled: boolean; disconnect: (() => void) | null };
 type CanApply<P extends GObject.Object, V> = (object: P, value: V) => boolean;
 type ChildSetter = GObject.Object & { setChild: (child: Gtk.Widget | null) => void };
 type ContentSetter<C extends Gtk.Widget> = GObject.Object & { setContent: (content: C | null) => void };
@@ -170,15 +171,13 @@ const list = <P extends GObject.Object, I, H = void>(
     return behavior;
 };
 
-const flushDeferred = <P extends GObject.Object, V>(
+const settleDeferred = <P extends GObject.Object, V>(
     object: GObject.Object,
-    context: unknown,
+    state: DeferredState,
     prop: string,
     canApply: CanApply<P, V> | undefined,
 ): void => {
-    const state = context as DeferredState;
-
-    if (!state.isPresent || Object.is(state.applied, state.desired)) {
+    if (!state.isPresent || Object.is(Reflect.get(object, prop), state.desired)) {
         return;
     }
 
@@ -186,11 +185,53 @@ const flushDeferred = <P extends GObject.Object, V>(
         return;
     }
 
-    applyWrite(() => {
+    applyWrite(prop, () => {
         Reflect.set(object, prop, state.desired);
     });
+};
+
+const scheduleSettle = <P extends GObject.Object, V>(
+    object: GObject.Object,
+    state: DeferredState,
+    prop: string,
+    canApply: CanApply<P, V> | undefined,
+): void => {
+    if (state.isScheduled) {
+        return;
+    }
+
+    state.isScheduled = true;
+
+    queueMicrotask(() => {
+        state.isScheduled = false;
+
+        if (state.disconnect !== null) {
+            settleDeferred(object, state, prop, canApply);
+        }
+    });
+};
 
-    state.applied = state.desired;
+const watchDrift = <P extends GObject.Object, V>(
+    object: GObject.Object,
+    state: DeferredState,
+    prop: string,
+    canApply: CanApply<P, V> | undefined,
+): void => {
+    if (state.disconnect !== null) {
+        return;
+    }
+
+    const signal = `notify::${getPropertyName(object, prop) ?? unsanitizeIdentifier(kebabCase(prop))}`;
+
+    const handler = (): undefined => {
+        scheduleSettle(object, state, prop, canApply);
+    };
+
+    object.on(signal, handler);
+
+    state.disconnect = (): void => {
+        object.off(signal, handler);
+    };
 };
 
 const deferred = <P extends GObject.Object, V>(
@@ -198,7 +239,7 @@ const deferred = <P extends GObject.Object, V>(
     canApply?: CanApply<P, V>,
 ): ElementBehavior<P> => ({
     deferred: [prop],
-    initialize: (): DeferredState => ({ desired: undefined, isPresent: false, applied: undefined }),
+    initialize: (): DeferredState => ({ desired: undefined, isPresent: false, isScheduled: false, disconnect: null }),
     update: (_object, _prev, next, context) => {
         const state = context as DeferredState;
         state.desired = next[prop];
@@ -207,14 +248,21 @@ const deferred = <P extends GObject.Object, V>(
         return [prop];
     },
     flush: (object, context) => {
-        flushDeferred(object, context, prop, canApply);
+        const state = context as DeferredState;
+        settleDeferred(object, state, prop, canApply);
+        watchDrift(object, state, prop, canApply);
+    },
+    teardown: (_object, context) => {
+        const state = context as DeferredState;
+        state.disconnect?.();
+        state.disconnect = null;
     },
 });
 
 const controlledText = (prop: string): ElementBehavior =>
     value(prop, (object, next) => {
         if (!hasSameText(object, prop, next)) {
-            applyWrite(() => {
+            applyWrite(prop, () => {
                 Reflect.set(object, prop, next);
             });
         }

package/src/reconciler/host-config.ts

@@ -14,6 +14,7 @@ import {
     assertPropsCanChange,
     flushAccessible,
     flushBehaviors,
+    teardownBehaviors,
 } from "./apply-props.js";
 import { attachChild, detachChild } from "./child-routing.js";
 import { resolveElementNode } from "./instance.js";
@@ -161,7 +162,7 @@ const hostConfig = {
     suspendInstance: (): void => undefined,
     waitForCommitToBeReady: (): null => null,
     NotPendingTransition: null,
-    HostTransitionContext: createContext(null) as unknown as ReactReconciler.ReactContext<null>,
+    HostTransitionContext: createContext(null),
 };
 
 const reconciler: ReactReconciler.Reconciler<Container, Instance, TextNode, unknown, unknown, object> =
@@ -190,6 +191,7 @@ function createPriorityTracker(): PriorityTracker {
 
 const detachElement = (instance: ElementNode): void => {
     disconnectAllHandlers(instance);
+    teardownBehaviors(instance);
 
     if (instance.object instanceof Gtk.Widget) {
         releaseStyle(instance.object);

package/src/reconciler/metadata.ts

@@ -1,10 +1,21 @@
-import { TYPE_INVALID, typeFromName, typeInterfaces, typeName, typeParent } from "@gtkx/runtime";
+import type * as GObject from "@gtkx/gi/gobject";
+import {
+    type AnyClass,
+    getClassType,
+    getDeclaredPropertyName,
+    TYPE_INVALID,
+    typeFromName,
+    typeInterfaces,
+    typeName,
+    typeParent,
+} from "@gtkx/runtime";
 import { getOrInsert } from "@gtkx/utils";
-import { constructOnlyProps, constructProps, defaultProps, signals, userEventSignals } from "virtual:gtkx-config";
+import { properties, type PropertyEntry, signals, userEventSignals } from "virtual:gtkx-config";
 import { deferredProps, type ElementBehavior, ELEMENTS } from "./registry.js";
 
 type TypeInfo = {
     typeName: string;
+    properties: Record<string, PropertyEntry>;
     signals: Record<string, string>;
     userEventSignals: Set<string>;
     behaviors: ElementBehavior[];
@@ -17,6 +28,12 @@ type TypeInfo = {
     defaults: Record<string, unknown>;
 };
 
+const WRITABLE = 2;
+const CONSTRUCT = 4;
+const CONSTRUCT_ONLY = 8;
+const NAME = 0;
+const FLAGS = 1;
+const DEFAULT_VALUE = 2;
 const ancestryCache: Map<string, string[]> = new Map();
 const typeInfoCache: Map<string, TypeInfo> = new Map();
 
@@ -60,11 +77,29 @@ const addAll = <T>(target: Set<T>, source: Iterable<T> | undefined): void => {
 const accumulateAncestor = (info: TypeInfo, ancestor: string): void => {
     Object.assign(info.signals, signals[ancestor] ?? {});
     addAll(info.userEventSignals, userEventSignals[ancestor]);
-    addAll(info.constructOnly, constructOnlyProps[ancestor]);
-    addAll(info.construct, constructProps[ancestor]);
     info.behaviors.push(...(ELEMENTS[ancestor]?.behaviors ?? []));
 };
 
+const resolveProperty = (info: TypeInfo, name: string, entry: PropertyEntry): void => {
+    if ((entry[FLAGS] & CONSTRUCT_ONLY) !== 0) {
+        info.constructOnly.add(name);
+    }
+
+    if ((entry[FLAGS] & (WRITABLE | CONSTRUCT | CONSTRUCT_ONLY)) !== 0) {
+        info.construct.add(name);
+    }
+
+    if (entry.length > DEFAULT_VALUE) {
+        info.defaults[name] = entry[DEFAULT_VALUE];
+    }
+};
+
+const resolveProperties = (info: TypeInfo): void => {
+    for (const [name, entry] of Object.entries(info.properties)) {
+        resolveProperty(info, name, entry);
+    }
+};
+
 const applyBehaviorFlags = (info: TypeInfo, behavior: ElementBehavior): void => {
     if (behavior.flush !== undefined) {
         info.hasFlush = true;
@@ -85,6 +120,7 @@ const buildTypeInfo = (name: string): TypeInfo => {
 
     const info: TypeInfo = {
         typeName: name,
+        properties: {},
         signals: {},
         userEventSignals: new Set(),
         behaviors: [],
@@ -105,12 +141,32 @@ const buildTypeInfo = (name: string): TypeInfo => {
     info.isLazy = chain.some((ancestor) => ELEMENTS[ancestor]?.isLazy === true);
 
     for (const ancestor of chain.toReversed()) {
-        Object.assign(info.defaults, defaultProps[ancestor] ?? {});
+        Object.assign(info.properties, properties[ancestor] ?? {});
     }
 
+    resolveProperties(info);
+
     return info;
 };
 
 const typeInfoFor = (name: string): TypeInfo => getOrInsert(typeInfoCache, name, buildTypeInfo);
 
-export { typeInfoFor, type TypeInfo };
+const getTypeInfo = (object: GObject.Object): TypeInfo | undefined => {
+    const name = typeName(getClassType(object.constructor as AnyClass));
+
+    return name === null ? undefined : typeInfoFor(name);
+};
+
+const hasProperty = (info: TypeInfo, accessor: string): boolean => Object.hasOwn(info.properties, accessor);
+
+const propertyNameFor = (info: TypeInfo, accessor: string): string | undefined =>
+    info.properties[accessor]?.[NAME];
+
+const getPropertyName = (object: GObject.Object, accessor: string): string | undefined => {
+    const info = getTypeInfo(object);
+
+    return (info === undefined ? undefined : propertyNameFor(info, accessor)) ??
+        getDeclaredPropertyName(object, accessor);
+};
+
+export { getPropertyName, hasProperty, typeInfoFor, type TypeInfo };