@gtkx/react 1.0.0-rc.3 → 1.0.0

package/src/element-config.ts

@@ -4,7 +4,6 @@ const SINGLE_CHILD_TYPES: string[] = [
     "GtkAspectFrame",
     "GtkButton",
     "GtkCheckButton",
-    "GtkComboBox",
     "GtkDragIcon",
     "GtkExpander",
     "GtkFlowBoxChild",
@@ -25,14 +24,15 @@ const SINGLE_CHILD_TYPES: string[] = [
 ];
 
 /**
- * The static, runtime-free half of the built-in element configuration: which base props interface each
- * generated element extends, which component wraps it, and whether its GObject is created lazily by its
- * parent. Codegen imports this module, so it must never reach the GObject bindings.
+ * The framework's own element configuration for the GTK types it customizes: the base props interface each
+ * generated element extends, the component that wraps it, the GObject properties left out of its generated
+ * props, and whether its GObject is created by its parent. Carries no behaviors, so importing it never
+ * reaches the GObject bindings.
  */
 const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
     ...forTypes(SINGLE_CHILD_TYPES, {
         props: internal("ChildrenProps"),
-        omitProps: ["child"],
+        omittedProps: ["child"],
     }),
     ...forTypes(["GtkHeaderBar", "GtkActionBar"], {
         props: internal("GtkHeaderBarProps"),
@@ -40,7 +40,10 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
     GtkWindow: {
         props: internal("ChildrenProps"),
         component: internal("createWindowComponent"),
-        omitProps: ["child"],
+        omittedProps: ["child"],
+    },
+    GtkApplicationWindow: {
+        component: internal("createApplicationWindowComponent"),
     },
     GtkLabel: {
         props: internal("ChildrenProps"),
@@ -55,22 +58,22 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
         props: internal("GtkTextChildAnchorProps"),
     },
     GtkGridLayoutChild: {
-        lazy: true,
+        isLazy: true,
     },
     GtkFixedLayoutChild: {
-        lazy: true,
+        isLazy: true,
     },
     GtkOverlayLayoutChild: {
-        lazy: true,
+        isLazy: true,
     },
     GtkStackPage: {
-        lazy: true,
+        isLazy: true,
     },
     GtkNotebookPage: {
-        lazy: true,
+        isLazy: true,
     },
     GActionGroup: {
-        props: internal("GActionGroupProps"),
+        props: internal("ActionGroupProps"),
     },
     GtkWidget: {
         props: internal("GtkWidgetProps"),
@@ -86,7 +89,7 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
     },
     GtkOverlay: {
         props: internal("GtkOverlayProps"),
-        omitProps: ["child"],
+        omittedProps: ["child"],
     },
     GtkShortcutController: {
         props: internal("GtkShortcutControllerProps"),
@@ -95,10 +98,10 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
         props: internal("ChildrenProps"),
     },
     GActionMap: {
-        props: internal("GActionMapProps"),
+        props: internal("ActionMapProps"),
     },
     GMenu: {
-        props: internal("GMenuProps"),
+        props: internal("MenuProps"),
     },
     GtkColumnView: {
         props: internal("ChildrenProps"),
@@ -111,6 +114,7 @@ const BUILTIN_ELEMENTS: Record<string, ElementConfig> = {
     },
     GtkSizeGroup: {
         props: internal("GtkSizeGroupProps"),
+        component: internal("createPortaledComponent"),
     },
     GtkConstraintLayout: {
         props: internal("GtkConstraintLayoutProps"),

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

@@ -6,22 +6,23 @@ import type { SettingsSchema, SettingsSchemaKeys } from "../utils/settings.js";
 import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 import { useSettings } from "./use-setting.js";
 
+/** Options for {@link useBindSetting}. */
 type UseBindSettingOptions<K extends SettingsSchemaKeys> = {
+    /** Schema the settings object is opened from. */
     schema: SettingsSchema<K>;
+    /** Key of that schema to bind. */
     key: keyof K & string;
+    /** Object holding the property, given directly or as a ref; nothing is bound while it is absent. */
     object: RefProp<GObject.Object>;
+    /** camelCase name of the property to keep in sync with the key. */
     property: string;
+    /** Direction and conversion behavior of the bind; defaults to `Gio.SettingsBindFlags.DEFAULT`. */
     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.
+ * Binds a GSettings key to a property of a GObject, keeping the two in sync until the component unmounts.
+ * `property` is given in camelCase, and `flags` defaults to `Gio.SettingsBindFlags.DEFAULT`, a two-way bind.
  */
 function useBindSetting<K extends SettingsSchemaKeys>({
     schema,

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

@@ -61,4 +61,4 @@ function useMergedRef<T>(first: PossibleRef<T>, second: PossibleRef<T>): RefCall
     return useMemo(() => mergeRefs(first, second), [first, second]);
 }
 
-export { assignRef, mergeRefs, useMergedRef };
+export { useMergedRef };

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

@@ -4,7 +4,9 @@ import { type Context, createContext, use } from "react";
 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.
+ * Returns the `Gtk.Window` of the nearest window ancestor. This is `null` on the first render even inside a
+ * window, because a window provides itself only once its GObject exists, and stays `null` outside one. The
+ * component re-renders when it resolves, so derive from the value rather than reading it once.
  */
 const useParentWindow = (): Gtk.Window | null => use(ParentWindowContext);
 

package/src/hooks/use-presented-instance.tsx

@@ -0,0 +1,50 @@
+import { type ElementType, type ReactNode, type Ref, type RefCallback, useLayoutEffect, useState } from "react";
+import { useMergedRef } from "./use-merged-refs.js";
+
+type PresentedProps<T> = {
+    ref?: Ref<T | null> | undefined;
+};
+
+type PresentedOptions<T> = {
+    usePresent: () => (instance: T) => void;
+    dismiss: (instance: T) => void;
+    wrap?: (element: ReactNode, instance: T | null) => ReactNode;
+};
+
+const usePresentedInstance = <T,>(
+    ref: Ref<T | null> | undefined,
+    present: (instance: T) => void,
+    dismiss: (instance: T) => void,
+): [T | null, RefCallback<T>] => {
+    const [instance, setInstance] = useState<T | null>(null);
+    const mergedRef = useMergedRef(ref, setInstance);
+
+    useLayoutEffect(() => {
+        if (!instance) {
+            return;
+        }
+
+        present(instance);
+
+        return () => {
+            dismiss(instance);
+        };
+    }, [instance, present, dismiss]);
+
+    return [instance, mergedRef];
+};
+
+const createPresentedComponent = <T,>(
+    Component: ElementType,
+    options: PresentedOptions<T>,
+): ((props: PresentedProps<T>) => ReactNode) => {
+    return ({ ref, ...rest }: PresentedProps<T>): ReactNode => {
+        const present = options.usePresent();
+        const [instance, mergedRef] = usePresentedInstance(ref, present, options.dismiss);
+        const element = <Component ref={mergedRef} {...rest} />;
+
+        return options.wrap ? options.wrap(element, instance) : element;
+    };
+};
+
+export { createPresentedComponent, type PresentedProps };

package/src/hooks/use-property.ts

@@ -3,15 +3,16 @@ import { kebabCase } from "@gtkx/utils";
 import type { RefProp } from "../utils/ref-prop.js";
 import { useObjectValue } from "./use-object-value.js";
 
+/** The property map `T` declares, from camelCase property name to value type. */
 type Properties<T extends GObject.Object> = NonNullable<T["__properties__"]>;
+/** Every property `T` declares that is also readable off the instance, in camelCase. */
 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.
  *
- * @param object The GObject (or ref to one) whose property to observe.
  * @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.
+ * @returns The current value, or `undefined` while the object is null or an unresolved ref.
  */
 function useProperty<T extends GObject.Object, P extends PropertyName<T>>(
     object: RefProp<T>,
@@ -20,4 +21,4 @@ function useProperty<T extends GObject.Object, P extends PropertyName<T>>(
     return useObjectValue(object, `notify::${kebabCase(propertyName)}`, (obj) => obj?.[propertyName]);
 }
 
-export { useProperty, type PropertyName };
+export { useProperty };

package/src/hooks/use-setting.ts

@@ -16,9 +16,8 @@ const useSettings = <K extends SettingsSchemaKeys>({ id, path }: UseSettingsProp
 /**
  * Reads and writes a single key of a GSettings schema, re-rendering when the stored value changes.
  *
- * @param schema The schema reference identifying the settings backend.
- * @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.
+ * @returns The current value, and a setter that writes a new one back to GSettings.
+ * @throws When the key is not declared in the schema.
  */
 function useSetting<K extends SettingsSchemaKeys, P extends keyof K>(
     schema: SettingsSchema<K>,

package/src/hooks/use-signal.ts

@@ -3,9 +3,15 @@ import type { SignalHandler } from "@gtkx/runtime";
 import { useEffectEvent, useLayoutEffect } from "react";
 import { type RefProp, resolveRefProp } from "../utils/ref-prop.js";
 
+/** The signal map `T` declares, from signal name to handler signature. */
 type Signals<T extends GObject.Object> = NonNullable<T["__signals__"]>;
+/** Every signal name `T` declares, on its own or narrowed by a `::detail` suffix. */
 type SignalName<T extends GObject.Object> = keyof Signals<T> | `${keyof Signals<T> & string}::${string}`;
 
+/**
+ * The handler signature `T` declares for signal `S`, looked up through any `::detail` suffix and
+ * falling back to an untyped `SignalHandler` when the object declares no such signal.
+ */
 type TypedSignalHandler<T extends GObject.Object, S extends string> = S extends keyof Signals<T>
     ? Signals<T>[S]
     : S extends `${infer TBase}::${string}`
@@ -14,9 +20,12 @@ type TypedSignalHandler<T extends GObject.Object, S extends string> = S extends
             : SignalHandler
         : SignalHandler;
 
+/** Options for {@link useSignal}. */
 type UseSignalOptions = {
-    after?: boolean;
-    immediate?: boolean;
+    /** Runs the handler after the object's own default handler rather than before it. */
+    isAfter?: boolean;
+    /** Invokes the handler once, with no arguments, as soon as the signal is connected. */
+    isImmediate?: boolean;
 };
 
 /**
@@ -29,16 +38,14 @@ type UseSignalOptions = {
  * 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.
+ * @param signal The signal name, optionally with a `::detail` suffix.
+ * @param options `isAfter` runs the handler after the default handler; `isImmediate` also invokes it on connect.
  */
 function useSignal<T extends GObject.Object, S extends SignalName<T> & string>(
     object: RefProp<T>,
     signal: S,
     handler: TypedSignalHandler<T, S>,
-    { after = false, immediate = false }: UseSignalOptions = {},
+    { isAfter = false, isImmediate = false }: UseSignalOptions = {},
 ): void {
     const emit = useEffectEvent(handler as SignalHandler);
 
@@ -49,16 +56,16 @@ function useSignal<T extends GObject.Object, S extends SignalName<T> & string>(
             return;
         }
 
-        resolved.on(signal, emit, after);
+        resolved.on(signal, emit, isAfter);
 
-        if (immediate) {
+        if (isImmediate) {
             emit();
         }
 
         return () => {
             resolved.off(signal, emit);
         };
-    }, [object, signal, after, immediate]);
+    }, [object, signal, isAfter, isImmediate]);
 }
 
-export { useSignal, type SignalName, type TypedSignalHandler };
+export { useSignal };

package/src/index.ts

@@ -1,14 +1,22 @@
 import "./bootstrap.js";
 
+/** @public */
 export { useApplication } from "./hooks/use-application.js";
+/** @public */
 export { useBindSetting } from "./hooks/use-bind-setting.js";
+/** @public */
 export { useParentWindow } from "./hooks/use-parent-window.js";
+/** @public */
 export { useProperty } from "./hooks/use-property.js";
+/** @public */
 export { useSetting } from "./hooks/use-setting.js";
+/** @public */
 export { useSignal } from "./hooks/use-signal.js";
-export type { MenuItem, VflConstraints } from "./prop-types.js";
+/** @public */
 export { type RootElement, rootElement } from "./reconciler/root-element.js";
+/** @public */
 export { createPortal, createRoot, quit, type Root } from "./reconciler/root.js";
+/** @public */
 export type { AccessibleProps } from "./utils/accessible-props.js";
+/** @public */
 export type { RefProp } from "./utils/ref-prop.js";
-export type { SettingsSchema, SettingsSchemaKeys, SettingValue } from "./utils/settings.js";

package/src/internal.ts

@@ -1,14 +1,17 @@
 import "./bootstrap.js";
 
+/** @internal */
+export { createApplicationWindowComponent } from "./components/application-window.js";
+/** @internal */
 export { createApplicationComponent } from "./components/application.js";
 export { createElementComponent } from "./components/element.js";
+/** @internal */
+export { createPortaledComponent } from "./components/portaled.js";
+/** @internal */
 export { createWindowComponent } from "./components/window.js";
-export { ApplicationContext } from "./hooks/use-application.js";
 export { useMergedRef } from "./hooks/use-merged-refs.js";
-export { useObjectValue } from "./hooks/use-object-value.js";
 export type * from "./prop-types.js";
+export { settleAccessible } from "./reconciler/apply-props.js";
 export { isRootElement } from "./reconciler/root-element.js";
 export { createReconcilerRoot, type ReconcilerRoot, setReconcilerErrorHandler } from "./reconciler/root.js";
-export { applyWrite } from "./reconciler/signals.js";
-export { getAccessibleMetadata } from "./utils/accessible-metadata.js";
-export { type RefProp, resolveRefProp } from "./utils/ref-prop.js";
+export type { SettingsSchema, SettingsSchemaKeys, SettingValue } from "./utils/settings.js";

package/src/prop-types.ts

@@ -1,114 +1,221 @@
+/* eslint-disable gtkx/no-library-prefix */
 import type * as Gdk from "@gtkx/gi/gdk";
+import type * as GLib from "@gtkx/gi/glib";
 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 = {
+    /** Text shown for the entry, or the heading of the submenu or section it introduces. */
     label?: string | null;
+    /** Detailed action name the entry activates, ignored when `submenu` or `section` is given. */
     action?: string | null;
+    /** Entries of a separate menu the labelled entry opens. */
     submenu?: MenuItem[];
+    /** Entries appended below the label as an inline section, used only when `submenu` is absent. */
     section?: MenuItem[];
 };
 
 /** One Visual Format Language block applied to a `Gtk.ConstraintLayout`. */
 type VflConstraints = {
+    /** Format lines, each describing every constraint on one row or column. */
     lines: string[];
+    /** Default horizontal spacing the `-` operator stands for; defaults to 0. */
     hspacing?: number;
+    /** Default vertical spacing the `-` operator stands for; defaults to 0. */
     vspacing?: number;
+    /** Targets the view names in `lines` refer to; defaults to none. */
     views?: Map<string, Gtk.ConstraintTarget>;
 };
 
 /** One mark on a `Gtk.Scale`. */
-type ScaleMark = { value?: number; position: Gtk.PositionType; markup?: string | null };
+type ScaleMark = {
+    /** Point on the scale the mark is drawn at; defaults to 0. */
+    value?: number;
+    /** Side of the scale the mark and its label sit on. */
+    position: Gtk.PositionType;
+    /** Pango markup drawn beside the mark, or `null` for an unlabelled one. */
+    markup?: string | null;
+};
+
 /** One labelled offset on a `Gtk.LevelBar`. */
-type LevelBarOffset = { name: string; value?: number };
+type LevelBarOffset = {
+    /** Style class applied to the bar's blocks while the value falls in this offset's interval. */
+    name: string;
+    /** Upper bound of that interval; defaults to 0. */
+    value?: number;
+};
+
 /** One credit section on a `Gtk.AboutDialog`. */
-type CreditSection = { sectionName: string; people: string[] };
+type CreditSection = {
+    /** Heading the names are listed under. */
+    sectionName: string;
+    /** Names listed in the section. */
+    people: string[];
+};
+
+/** One command-line option a `Gtk.Application` accepts. */
+type MainOption = {
+    /** Name the option is spelled with after two dashes, such as `verbose` for `--verbose`. */
+    longName: string;
+    /** Single character the option is spelled with after one dash, such as `v` for `-v`; defaults to none. */
+    shortName?: string | null;
+    /** How the option itself is parsed and listed; defaults to `GLib.OptionFlags.NONE`. */
+    flags?: GLib.OptionFlags;
+    /** Type of argument the option takes; defaults to `GLib.OptionArg.NONE`, meaning it takes none. */
+    arg?: GLib.OptionArg;
+    /** Text describing the option in `--help`. */
+    description: string;
+    /** Placeholder standing for the option's argument in `--help`; defaults to none. */
+    argDescription?: string | null;
+};
+
 /** One accelerator binding on a `Gtk.Application`. */
-type ActionAccel = { detailedActionName: string; accels: string[] };
+type ActionAccel = {
+    /** Action the accelerators activate, such as `app.quit` or `win.open('file')`. */
+    detailedActionName: string;
+    /** Accelerators in `Gtk.acceleratorParse` syntax, cleared when the entry goes away. */
+    accels: string[];
+};
+
 /** The drag icon of a `Gtk.DragSource`, with its hotspot. */
-type DragSourceIcon = { paintable?: Gdk.Paintable | null; hotX?: number; hotY?: number };
+type DragSourceIcon = {
+    /** Image shown under the pointer during the drag; defaults to none. */
+    paintable?: Gdk.Paintable | null;
+    /** Horizontal offset of the pointer within the image; defaults to 0. */
+    hotX?: number;
+    /** Vertical offset of the pointer within the image; defaults to 0. */
+    hotY?: number;
+};
 
 /** Props of an element that accepts children. */
 type ChildrenProps = {
+    /** Elements attached to the element's default child slot, or its text for elements that hold text. */
     children?: ReactNode;
 };
 
+/** Objects a widget takes through a method call rather than a property. */
 type GtkWidgetProps = {
+    /** `Gtk.EventController` elements added to the widget. */
     controllers?: ReactNode | null | undefined;
+    /** `Gio.ActionGroup` elements inserted into the widget, each under its own `prefix`. */
     actionGroups?: ReactNode | null | undefined;
 } & ChildrenProps;
 
-type GActionGroupProps = {
+/** Props of an action group placed in a widget's `actionGroups` slot. */
+type ActionGroupProps = {
+    /** Prefix the group's actions are addressed by, such as `win`; defaults to the empty string. */
     prefix?: string | null | undefined;
 };
 
-type GActionMapProps = {
+/** Props of an element implementing `Gio.ActionMap`. */
+type ActionMapProps = {
+    /** `Gio.Action` elements added to the map, removed again by their `name`. */
     actions?: ReactNode | null | undefined;
 };
 
-type GMenuProps = {
+/** Props of a `Gio.Menu` element. */
+type MenuProps = {
+    /** Entries the menu is rebuilt from whenever they change. */
     items?: MenuItem[] | null | undefined;
 };
 
+/** Props of a `Gtk.ShortcutController` element. */
 type GtkShortcutControllerProps = {
+    /** `Gtk.Shortcut` elements the controller watches for. */
     shortcuts?: ReactNode | null | undefined;
 };
 
+/** Props of a `Gtk.Overlay` element, whose `children` is the widget the overlays sit above. */
 type GtkOverlayProps = {
+    /** Widgets stacked over the main child. */
     overlays?: ReactNode | null | undefined;
 } & ChildrenProps;
 
+/** Props of a `Gtk.ConstraintLayout` element. */
 type GtkConstraintLayoutProps = {
+    /** `Gtk.Constraint` elements added to the layout. */
     constraints?: ReactNode | null | undefined;
+    /** `Gtk.ConstraintGuide` elements added to the layout as invisible spacers. */
     guides?: ReactNode | null | undefined;
+    /** Visual Format Language blocks whose constraints are added alongside `constraints`. */
     vfl?: VflConstraints[] | null | undefined;
 };
 
 /** Props of `GtkTextChildAnchor`, which embeds either a child widget or a paintable in a text buffer. */
 type GtkTextChildAnchorProps = {
+    /** Image inserted into the buffer instead of an anchored widget; giving both is an error. */
     paintable?: Gdk.Paintable | null | undefined;
 } & ChildrenProps;
 
+/** Props of a `Gtk.HeaderBar` or `Gtk.ActionBar` element. */
 type GtkHeaderBarProps = {
+    /** Widgets packed at the start of the bar. */
     start?: ReactNode | null | undefined;
+    /** Widgets packed at the end of the bar. */
     end?: ReactNode | null | undefined;
 };
 
+/** Props of a `Gtk.Scale` element. */
 type GtkScaleProps = {
+    /** Marks drawn along the scale, cleared and re-added whenever the list changes. */
     marks?: ScaleMark[] | null | undefined;
 };
 
+/** Props of a `Gtk.Calendar` element. */
 type GtkCalendarProps = {
+    /** Days of the shown month drawn as marked, cleared and re-marked whenever the list changes. */
     markedDays?: number[] | null | undefined;
 };
 
+/** Props of a `Gtk.LevelBar` element. */
 type GtkLevelBarProps = {
+    /** Offsets that split the bar's range into differently styled intervals. */
     offsets?: LevelBarOffset[] | null | undefined;
 };
 
+/** Props of a `Gtk.SizeGroup` element. */
 type GtkSizeGroupProps = {
+    /** Widgets the group keeps at a common size. */
     widgets?: Gtk.Widget[] | null | undefined;
 };
 
+/** Props of a `Gtk.AboutDialog` element. */
 type GtkAboutDialogProps = {
+    /**
+     * Extra sections appended to the dialog's credits. GTK offers no way to remove one, so the list
+     * cannot change once it has been applied.
+     */
     creditSections?: CreditSection[] | null | undefined;
 };
 
+/** Props of a `Gtk.Application` element, whose `children` are the windows it owns. */
 type GtkApplicationProps = {
+    /** Accelerators bound to the application's actions. */
     actionAccels?: ActionAccel[] | null | undefined;
+    /**
+     * Command-line options the application parses, registered before it starts. GLib offers no way to
+     * unregister one, so the list cannot change once it has been applied.
+     */
+    mainOptions?: MainOption[] | null | undefined;
 } & ChildrenProps;
 
+/** Props of a `Gtk.DropTarget` element. */
 type GtkDropTargetProps = {
+    /** GTypes the target accepts a drop of. */
     types?: GObject.Type[] | null | undefined;
 };
 
+/** Props of a `Gtk.DrawingArea` element. */
 type GtkDrawingAreaProps = {
+    /** Callback that draws the area's contents; setting it queues a redraw. */
     drawFunc?: Gtk.DrawingAreaDrawFunc | null | undefined;
 };
 
+/** Props of a `Gtk.DragSource` element. */
 type GtkDragSourceProps = {
+    /** Icon shown under the pointer while a drag started from this source is in flight. */
     icon?: DragSourceIcon | null | undefined;
 };
 
@@ -118,13 +225,14 @@ export {
     type ScaleMark,
     type LevelBarOffset,
     type CreditSection,
+    type MainOption,
     type ActionAccel,
     type DragSourceIcon,
     type ChildrenProps,
     type GtkWidgetProps,
-    type GActionGroupProps,
-    type GActionMapProps,
-    type GMenuProps,
+    type ActionGroupProps,
+    type ActionMapProps,
+    type MenuProps,
     type GtkShortcutControllerProps,
     type GtkOverlayProps,
     type GtkTextChildAnchorProps,