@gtkx/react 1.0.0-rc.1 → 1.0.0-rc.3

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

@@ -1,35 +1,51 @@
-import * as Gio from "@gtkx/gi/gio";
 import type * as GObject from "@gtkx/gi/gobject";
-import { toKebabCase } from "@gtkx/utils";
-import type { ObjectProp } from "../utils/object-prop.js";
-import { useObjectAttachment } from "./use-object-attachment.js";
-import { type SchemaRef, useSettingsInstance } from "./use-setting.js";
+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 { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
+import { useSettings } from "./use-setting.js";
+
+type UseBindSettingOptions<K extends SettingsSchemaKeys> = {
+    schema: SettingsSchema<K>;
+    key: keyof K & string;
+    object: RefProp<GObject.Object>;
+    property: string;
+    flags?: Gio.SettingsBindFlags;
+};
+
+/**
+ * Binds a GSettings key to a property of a GObject, keeping the two in sync for the object's lifetime.
+ *
+ * @param options.schema The schema reference identifying the settings backend.
+ * @param options.key The key within the schema to bind.
+ * @param options.object The GObject whose property is bound to the setting.
+ * @param options.property The name of the object property to bind.
+ * @param options.flags Flags controlling the binding's direction and behaviour.
+ */
+function useBindSetting<K extends SettingsSchemaKeys>({
+    schema,
+    key,
+    object,
+    property,
+    flags = Gio.SettingsBindFlags.DEFAULT,
+}: UseBindSettingOptions<K>): void {
+    const settings = useSettings(schema);
+    const propertyName = kebabCase(property);
 
-export function useBindSetting<K extends object, P extends keyof K & string>(
-    schema: SchemaRef<K>,
-    key: P,
-    object: ObjectProp<GObject.Object>,
-    property: string,
-    flags?: Gio.SettingsBindFlags,
-): void;
-export function useBindSetting(
-    schema: SchemaRef,
-    key: string,
-    object: ObjectProp<GObject.Object>,
-    property: string,
-    flags: Gio.SettingsBindFlags = Gio.SettingsBindFlags.DEFAULT,
-): void {
-    const settings = useSettingsInstance(schema);
-    const propertyName = toKebabCase(property);
+    useLayoutEffect(() => {
+        const resolved = resolveRefProp(object);
 
-    useObjectAttachment<GObject.Object, GObject.Object>(object, {
-        attach: (obj) => {
-            settings.bind(key, obj, propertyName, flags);
-            return obj;
-        },
-        detach: (obj) => {
-            Gio.Settings.unbind(obj, propertyName);
-        },
-        isSame: (attachment, current) => attachment === current,
-    });
+        if (!resolved) {
+            return;
+        }
+
+        settings.bind(key, resolved, propertyName, flags);
+
+        return () => {
+            Gio.Settings.unbind(resolved, propertyName);
+        };
+    }, [settings, key, object, propertyName, flags]);
 }
+
+export { useBindSetting };

package/src/hooks/use-merged-refs.ts

@@ -0,0 +1,64 @@
+import { isRecord } from "@gtkx/utils";
+import { type Ref, type RefCallback, useMemo } from "react";
+
+type PossibleRef<T> = Ref<T> | undefined;
+type RefCleanup<T> = ReturnType<RefCallback<T>>;
+type CleanupMap<T> = Map<PossibleRef<T>, Exclude<RefCleanup<T>, void>>;
+
+function assignRef<T>(ref: PossibleRef<T>, value: T): RefCleanup<T> {
+    if (typeof ref === "function") {
+        return ref(value);
+    }
+
+    if (isRecord(ref) && "current" in ref) {
+        ref.current = value;
+    }
+}
+
+function collectCleanup<T>(cleanupMap: CleanupMap<T>, ref: PossibleRef<T>, node: T | null): void {
+    const cleanup = assignRef(ref, node);
+
+    if (cleanup) {
+        cleanupMap.set(ref, cleanup);
+    }
+}
+
+function cleanupRef<T>(cleanupMap: CleanupMap<T>, ref: PossibleRef<T>): void {
+    const cleanup = cleanupMap.get(ref);
+
+    if (cleanup && typeof cleanup === "function") {
+        cleanup();
+    } else {
+        assignRef(ref, null);
+    }
+}
+
+function applyRefs<T>(cleanupMap: CleanupMap<T>, refs: PossibleRef<T>[], node: T | null): RefCleanup<T> {
+    for (const ref of refs) {
+        collectCleanup(cleanupMap, ref, node);
+    }
+
+    if (cleanupMap.size === 0) {
+        return;
+    }
+
+    return () => {
+        for (const ref of refs) {
+            cleanupRef(cleanupMap, ref);
+        }
+
+        cleanupMap.clear();
+    };
+}
+
+function mergeRefs<T>(...refs: PossibleRef<T>[]): RefCallback<T> {
+    const cleanupMap: CleanupMap<T> = new Map();
+
+    return (node: T | null): RefCleanup<T> => applyRefs(cleanupMap, refs, node);
+}
+
+function useMergedRef<T>(first: PossibleRef<T>, second: PossibleRef<T>): RefCallback<T> {
+    return useMemo(() => mergeRefs(first, second), [first, second]);
+}
+
+export { assignRef, mergeRefs, useMergedRef };

package/src/hooks/use-object-value.ts

@@ -1,7 +1,7 @@
 import type * as GObject from "@gtkx/gi/gobject";
 import type { SignalHandler } from "@gtkx/runtime";
 import { useCallback, useRef, useSyncExternalStore } from "react";
-import { type ObjectProp, resolveObjectProp } from "../utils/object-prop.js";
+import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 
 type ObjectValueCache<T extends GObject.Object, V> = {
     object: T | null;
@@ -9,42 +9,46 @@ type ObjectValueCache<T extends GObject.Object, V> = {
     value: V;
 };
 
-export function useObjectValue<T extends GObject.Object, V>(
-    object: ObjectProp<T>,
+function useObjectValue<T extends GObject.Object, V>(
+    object: RefProp<T>,
     signal: string,
     read: (object: T | null) => V,
 ): V {
-    const resolved = resolveObjectProp(object);
-    const readRef = useRef(read);
-    readRef.current = read;
+    const resolved = resolveRefProp(object);
     const cacheRef = useRef<ObjectValueCache<T, V> | null>(null);
 
-    const readNow = useCallback((): ObjectValueCache<T, V> => {
-        const cache = { object: resolved, signal, value: readRef.current(resolved) };
-        cacheRef.current = cache;
-        return cache;
-    }, [resolved, signal]);
-
-    const getSnapshot = useCallback((): V => {
-        const cache = cacheRef.current;
-        if (cache !== null && cache.object === resolved && cache.signal === signal) {
-            return cache.value;
-        }
-        return readNow().value;
-    }, [resolved, signal, readNow]);
-
     const subscribe = useCallback(
         (onStoreChange: () => void): (() => void) => {
-            if (resolved === null) return () => {};
+            if (resolved === null) {
+                return (): void => undefined;
+            }
+
             const handler: SignalHandler = () => {
-                readNow();
+                cacheRef.current = null;
                 onStoreChange();
             };
+
             resolved.on(signal, handler);
+
             return () => resolved.off(signal, handler);
         },
-        [resolved, signal, readNow],
+        [resolved, signal],
     );
 
+    const getSnapshot = (): V => {
+        const cache = cacheRef.current;
+
+        if (cache !== null && cache.object === resolved && cache.signal === signal) {
+            return cache.value;
+        }
+
+        const value = read(resolved);
+        cacheRef.current = { object: resolved, signal, value };
+
+        return value;
+    };
+
     return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
+
+export { useObjectValue };

package/src/hooks/use-parent-window.ts

@@ -1,9 +1,11 @@
 import type * as Gtk from "@gtkx/gi/gtk";
 import { type Context, createContext, use } from "react";
 
-export const ParentWindowContext: Context<Gtk.Window | null> = createContext<Gtk.Window | null>(null);
+const ParentWindowContext: Context<Gtk.Window | null> = createContext<Gtk.Window | null>(null);
 
 /**
  * Returns the `Gtk.Window` provided by the nearest window ancestor, or `null` when there is none.
  */
-export const useParentWindow = (): Gtk.Window | null => use(ParentWindowContext);
+const useParentWindow = (): Gtk.Window | null => use(ParentWindowContext);
+
+export { ParentWindowContext, useParentWindow };

package/src/hooks/use-property.ts

@@ -1,11 +1,10 @@
 import type * as GObject from "@gtkx/gi/gobject";
-import { propToNotifySignal } from "../utils/notify-name.js";
-import type { ObjectProp } from "../utils/object-prop.js";
+import { kebabCase } from "@gtkx/utils";
+import type { RefProp } from "../utils/ref-prop.js";
 import { useObjectValue } from "./use-object-value.js";
 
-type PropertiesOf<T extends GObject.Object> = NonNullable<T["__properties__"]>;
-
-export type PropertyNameOf<T extends GObject.Object> = keyof PropertiesOf<T> & keyof T & string;
+type Properties<T extends GObject.Object> = NonNullable<T["__properties__"]>;
+type PropertyName<T extends GObject.Object> = keyof Properties<T> & keyof T;
 
 /**
  * Subscribes to a GObject property and returns its current value, re-rendering when the property changes.
@@ -14,9 +13,11 @@ export type PropertyNameOf<T extends GObject.Object> = keyof PropertiesOf<T> & k
  * @param propertyName The camelCase name of a readable property on the object.
  * @returns The current property value, or `undefined` when the object is not resolved.
  */
-export function useProperty<T extends GObject.Object, K extends PropertyNameOf<T>>(
-    object: ObjectProp<T>,
-    propertyName: K,
-): T[K] | undefined {
-    return useObjectValue(object, propToNotifySignal(propertyName), (obj) => (obj ? obj[propertyName] : undefined));
+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]);
 }
+
+export { useProperty, type PropertyName };

package/src/hooks/use-setting.ts

@@ -1,23 +1,17 @@
 import * as Gio from "@gtkx/gi/gio";
-import { useCallback, useMemo } from "react";
-import { resolveAccessor } from "../utils/settings-accessor.js";
+import { useMemo } from "react";
+import {
+    resolveSettingAccessor,
+    type SettingsSchema,
+    type SettingsSchemaKeys,
+    type SettingValue,
+} from "../utils/settings.js";
 import { useObjectValue } from "./use-object-value.js";
 
-/**
- * A typed reference to a GSettings schema: its id, path, and the mapping of typed keys to their setting names.
- */
-export type SchemaRef<K extends object = Record<string, unknown>> = {
-    id: string;
-    /** The schema's object path, or `null` to use the schema's default path. */
-    path: string | null;
-    /** Maps each typed key of `K` to its corresponding GSettings key name. */
-    keys: { [P in keyof K]: string };
-    /** Phantom field carrying the value type `K`; never populated at runtime. */
-    __keys__?: K;
-};
+type UseSettingsProps<K extends SettingsSchemaKeys> = Pick<SettingsSchema<K>, "id" | "path">;
 
-export const useSettingsInstance = ({ id, path }: Pick<SchemaRef, "id" | "path">): Gio.Settings =>
-    useMemo(() => (path === null ? Gio.Settings.new(id) : new Gio.Settings({ schemaId: id, path })), [id, path]);
+const useSettings = <K extends SettingsSchemaKeys>({ id, path }: UseSettingsProps<K>): Gio.Settings =>
+    useMemo(() => (path ? new Gio.Settings({ schema: id, path }) : Gio.Settings.new(id)), [id, path]);
 
 /**
  * Reads and writes a single key of a GSettings schema, re-rendering when the stored value changes.
@@ -26,22 +20,15 @@ export const useSettingsInstance = ({ id, path }: Pick<SchemaRef, "id" | "path">
  * @param key The key within the schema to read and write.
  * @returns A tuple of the current value and a setter that persists a new value.
  */
-export function useSetting<K extends object, P extends keyof K & string>(
-    schema: SchemaRef<K>,
-    key: P,
-): [K[P], (value: K[P]) => void];
-export function useSetting(schema: SchemaRef, key: string): [unknown, (value: unknown) => void] {
-    const accessor = resolveAccessor(schema.keys[key], key, schema.id);
-    const settings = useSettingsInstance(schema);
-
-    const value = useObjectValue(settings, `changed::${key}`, () => accessor.read(settings, key));
+function useSetting<K extends SettingsSchemaKeys, P extends keyof K>(
+    schema: SettingsSchema<K>,
+    key: P & string,
+): [SettingValue<K, P>, (value: SettingValue<K, P>) => void] {
+    const settings = useSettings({ id: schema.id, path: schema.path });
+    const accessor = resolveSettingAccessor(settings, schema, key);
+    const value = useObjectValue(settings, `changed::${key}`, () => accessor.get());
 
-    const set = useCallback(
-        (newValue: unknown) => {
-            accessor.write(settings, key, newValue);
-        },
-        [accessor, settings, key],
-    );
-
-    return [value, set];
+    return [value, accessor.set];
 }
+
+export { useSettings, useSetting };

package/src/hooks/use-signal.ts

@@ -1,71 +1,64 @@
 import type * as GObject from "@gtkx/gi/gobject";
 import type { SignalHandler } from "@gtkx/runtime";
-import { useRef } from "react";
-import type { ObjectProp } from "../utils/object-prop.js";
-import { useObjectAttachment } from "./use-object-attachment.js";
+import { useEffectEvent, useLayoutEffect } from "react";
+import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 
-type AnySignalHandler = (...args: unknown[]) => unknown;
+type Signals<T extends GObject.Object> = NonNullable<T["__signals__"]>;
+type SignalName<T extends GObject.Object> = keyof Signals<T> | `${keyof Signals<T> & string}::${string}`;
 
-type SignalsOf<T extends GObject.Object> = NonNullable<T["__signals__"]>;
-
-export type SignalNameOf<T extends GObject.Object> =
-    | (keyof SignalsOf<T> & string)
-    | `${keyof SignalsOf<T> & string}::${string}`;
-
-export type SignalHandlerFor<T extends GObject.Object, S extends string> = S extends keyof SignalsOf<T>
-    ? SignalsOf<T>[S]
+type TypedSignalHandler<T extends GObject.Object, S extends string> = S extends keyof Signals<T>
+    ? Signals<T>[S]
     : S extends `${infer TBase}::${string}`
-      ? TBase extends keyof SignalsOf<T>
-          ? SignalsOf<T>[TBase]
-          : AnySignalHandler
-      : AnySignalHandler;
+        ? TBase extends keyof Signals<T>
+            ? Signals<T>[TBase]
+            : SignalHandler
+        : SignalHandler;
 
 type UseSignalOptions = {
     after?: boolean;
     immediate?: boolean;
 };
 
-type SignalSubscription = {
-    obj: GObject.Object;
-    signal: string;
-    after: boolean;
-    listener: SignalHandler;
-};
-
 /**
  * Connects a handler to a GObject signal for the lifetime of the component, reconnecting when the object changes.
  *
+ * Each emission runs the handler from the latest render, so it does not have to be stable and a
+ * changing handler never reconnects the signal.
+ *
+ * On React 19.2 this does not hold inside a component wrapped in `memo` or `forwardRef`, where every emission
+ * runs the handler captured on the first render. Keep the calling component unwrapped, or read the values the
+ * handler needs off the GObject itself. React fixes this on the 19.3 line.
+ *
  * @param object The GObject (or ref to one) to connect to.
  * @param signal The signal name, optionally with a detail suffix.
  * @param handler The callback invoked when the signal is emitted.
  * @param options Connection options such as running after the default handler or invoking immediately.
  */
-export function useSignal<T extends GObject.Object, S extends SignalNameOf<T>>(
-    object: ObjectProp<T>,
+function useSignal<T extends GObject.Object, S extends SignalName<T> & string>(
+    object: RefProp<T>,
     signal: S,
-    handler: SignalHandlerFor<T, S>,
-    options?: UseSignalOptions,
-): void;
-export function useSignal(
-    object: ObjectProp<GObject.Object>,
-    signal: string,
-    handler: AnySignalHandler,
-    options?: UseSignalOptions,
+    handler: TypedSignalHandler<T, S>,
+    { after = false, immediate = false }: UseSignalOptions = {},
 ): void {
-    const handlerRef = useRef(handler);
-    handlerRef.current = handler;
-    const after = options?.after ?? false;
-    const immediate = options?.immediate ?? false;
+    const emit = useEffectEvent(handler as SignalHandler);
 
-    useObjectAttachment<GObject.Object, SignalSubscription>(object, {
-        attach: (obj) => {
-            const listener: SignalHandler = (...args) => handlerRef.current(...args);
-            obj.on(signal, listener, after);
-            if (immediate) handlerRef.current();
-            return { obj, signal, after, listener };
-        },
-        detach: (subscription) => subscription.obj.off(subscription.signal, subscription.listener),
-        isSame: (subscription, obj) =>
-            subscription.obj === obj && subscription.signal === signal && subscription.after === after,
-    });
+    useLayoutEffect(() => {
+        const resolved = resolveRefProp(object);
+
+        if (!resolved) {
+            return;
+        }
+
+        resolved.on(signal, emit, after);
+
+        if (immediate) {
+            emit();
+        }
+
+        return () => {
+            resolved.off(signal, emit);
+        };
+    }, [object, signal, after, immediate]);
 }
+
+export { useSignal, type SignalName, type TypedSignalHandler };

package/src/index.ts

@@ -1,15 +1,14 @@
-import "./utils/wrapper-node-jsx.js";
+import "./bootstrap.js";
 
-export type { ElementProp } from "@gtkx/config";
 export { useApplication } from "./hooks/use-application.js";
 export { useBindSetting } from "./hooks/use-bind-setting.js";
 export { useParentWindow } from "./hooks/use-parent-window.js";
 export { useProperty } from "./hooks/use-property.js";
-export { type SchemaRef, useSetting } from "./hooks/use-setting.js";
+export { useSetting } from "./hooks/use-setting.js";
 export { useSignal } from "./hooks/use-signal.js";
-export type { AccessibleProps } from "./reconciler/accessible.js";
-export { createPortal } from "./reconciler/portal.js";
-export { createRoot, quit, type Root } from "./reconciler/render.js";
+export type { MenuItem, VflConstraints } from "./prop-types.js";
 export { type RootElement, rootElement } from "./reconciler/root-element.js";
-export type { ObjectProp } from "./utils/object-prop.js";
-export type { TextAnchorProps, TextPaintableProps } from "./utils/wrapper-node-jsx.js";
+export { createPortal, createRoot, quit, type Root } from "./reconciler/root.js";
+export type { AccessibleProps } from "./utils/accessible-props.js";
+export type { RefProp } from "./utils/ref-prop.js";
+export type { SettingsSchema, SettingsSchemaKeys, SettingValue } from "./utils/settings.js";

package/src/internal.ts

@@ -1,24 +1,14 @@
+import "./bootstrap.js";
+
 export { createApplicationComponent } from "./components/application.js";
+export { createElementComponent } from "./components/element.js";
 export { createWindowComponent } from "./components/window.js";
 export { ApplicationContext } from "./hooks/use-application.js";
-export { useMergeRefs } from "./hooks/use-merge-refs.js";
-export { useObjectAttachment } from "./hooks/use-object-attachment.js";
+export { useMergedRef } from "./hooks/use-merged-refs.js";
 export { useObjectValue } from "./hooks/use-object-value.js";
-export { setReconcilerErrorHandler } from "./reconciler/reconciler-error-handler.js";
-export { createReconcilerRoot, type ReconcilerRoot } from "./reconciler/reconciler-root.js";
+export type * from "./prop-types.js";
 export { isRootElement } from "./reconciler/root-element.js";
-export {
-    BUFFER_TEXT_KIND,
-    CONTAINER_PROP_KIND,
-    isWrapperKind,
-    LABEL_TEXT_KIND,
-    LAZY_ELEMENT_KIND,
-    OBJECT_PROP_KIND,
-    TEXT_ANCHOR_KIND,
-    TEXT_PAINTABLE_KIND,
-    WRAPPER_NODE_ELEMENT,
-    type WrapperKind,
-} from "./reconciler/wrapper-protocol.js";
+export { createReconcilerRoot, type ReconcilerRoot, setReconcilerErrorHandler } from "./reconciler/root.js";
+export { applyWrite } from "./reconciler/signals.js";
 export { getAccessibleMetadata } from "./utils/accessible-metadata.js";
-export { createElementComponent, createLazyElementComponent } from "./utils/create-element-component.js";
-export { type ObjectProp, resolveObjectProp } from "./utils/object-prop.js";
+export { type RefProp, resolveRefProp } from "./utils/ref-prop.js";

package/src/prop-types.ts

@@ -0,0 +1,142 @@
+import type * as Gdk from "@gtkx/gi/gdk";
+import type * as GObject from "@gtkx/gi/gobject";
+import type * as Gtk from "@gtkx/gi/gtk";
+import type { ReactNode } from "react";
+
+/** One entry of a `GMenu`'s `items` prop; `submenu` and `section` nest further menus. */
+type MenuItem = {
+    label?: string | null;
+    action?: string | null;
+    submenu?: MenuItem[];
+    section?: MenuItem[];
+};
+
+/** One Visual Format Language block applied to a `Gtk.ConstraintLayout`. */
+type VflConstraints = {
+    lines: string[];
+    hspacing?: number;
+    vspacing?: number;
+    views?: Map<string, Gtk.ConstraintTarget>;
+};
+
+/** One mark on a `Gtk.Scale`. */
+type ScaleMark = { value?: number; position: Gtk.PositionType; markup?: string | null };
+/** One labelled offset on a `Gtk.LevelBar`. */
+type LevelBarOffset = { name: string; value?: number };
+/** One credit section on a `Gtk.AboutDialog`. */
+type CreditSection = { sectionName: string; people: string[] };
+/** One accelerator binding on a `Gtk.Application`. */
+type ActionAccel = { detailedActionName: string; accels: string[] };
+/** The drag icon of a `Gtk.DragSource`, with its hotspot. */
+type DragSourceIcon = { paintable?: Gdk.Paintable | null; hotX?: number; hotY?: number };
+
+/** Props of an element that accepts children. */
+type ChildrenProps = {
+    children?: ReactNode;
+};
+
+type GtkWidgetProps = {
+    controllers?: ReactNode | null | undefined;
+    actionGroups?: ReactNode | null | undefined;
+} & ChildrenProps;
+
+type GActionGroupProps = {
+    prefix?: string | null | undefined;
+};
+
+type GActionMapProps = {
+    actions?: ReactNode | null | undefined;
+};
+
+type GMenuProps = {
+    items?: MenuItem[] | null | undefined;
+};
+
+type GtkShortcutControllerProps = {
+    shortcuts?: ReactNode | null | undefined;
+};
+
+type GtkOverlayProps = {
+    overlays?: ReactNode | null | undefined;
+} & ChildrenProps;
+
+type GtkConstraintLayoutProps = {
+    constraints?: ReactNode | null | undefined;
+    guides?: ReactNode | null | undefined;
+    vfl?: VflConstraints[] | null | undefined;
+};
+
+/** Props of `GtkTextChildAnchor`, which embeds either a child widget or a paintable in a text buffer. */
+type GtkTextChildAnchorProps = {
+    paintable?: Gdk.Paintable | null | undefined;
+} & ChildrenProps;
+
+type GtkHeaderBarProps = {
+    start?: ReactNode | null | undefined;
+    end?: ReactNode | null | undefined;
+};
+
+type GtkScaleProps = {
+    marks?: ScaleMark[] | null | undefined;
+};
+
+type GtkCalendarProps = {
+    markedDays?: number[] | null | undefined;
+};
+
+type GtkLevelBarProps = {
+    offsets?: LevelBarOffset[] | null | undefined;
+};
+
+type GtkSizeGroupProps = {
+    widgets?: Gtk.Widget[] | null | undefined;
+};
+
+type GtkAboutDialogProps = {
+    creditSections?: CreditSection[] | null | undefined;
+};
+
+type GtkApplicationProps = {
+    actionAccels?: ActionAccel[] | null | undefined;
+} & ChildrenProps;
+
+type GtkDropTargetProps = {
+    types?: GObject.Type[] | null | undefined;
+};
+
+type GtkDrawingAreaProps = {
+    drawFunc?: Gtk.DrawingAreaDrawFunc | null | undefined;
+};
+
+type GtkDragSourceProps = {
+    icon?: DragSourceIcon | null | undefined;
+};
+
+export {
+    type MenuItem,
+    type VflConstraints,
+    type ScaleMark,
+    type LevelBarOffset,
+    type CreditSection,
+    type ActionAccel,
+    type DragSourceIcon,
+    type ChildrenProps,
+    type GtkWidgetProps,
+    type GActionGroupProps,
+    type GActionMapProps,
+    type GMenuProps,
+    type GtkShortcutControllerProps,
+    type GtkOverlayProps,
+    type GtkTextChildAnchorProps,
+    type GtkConstraintLayoutProps,
+    type GtkHeaderBarProps,
+    type GtkScaleProps,
+    type GtkCalendarProps,
+    type GtkLevelBarProps,
+    type GtkSizeGroupProps,
+    type GtkAboutDialogProps,
+    type GtkApplicationProps,
+    type GtkDropTargetProps,
+    type GtkDrawingAreaProps,
+    type GtkDragSourceProps,
+};