@gtkx/react 0.1.11

package/dist/nodes/overlay.js

@@ -0,0 +1,109 @@
+import { appendChild, disconnectSignalHandlers, isConnectable, removeChild } from "../widget-capabilities.js";
+const isOverlayWidget = (widget) => "setChild" in widget &&
+    typeof widget.setChild === "function" &&
+    "addOverlay" in widget &&
+    typeof widget.addOverlay === "function" &&
+    "removeOverlay" in widget &&
+    typeof widget.removeOverlay === "function";
+export class OverlayNode {
+    static needsWidget = true;
+    static matches(type, widget) {
+        if (type !== "Overlay" && type !== "Overlay.Root")
+            return false;
+        return widget !== null && isOverlayWidget(widget);
+    }
+    widget;
+    mainChild = null;
+    overlayChildren = [];
+    signalHandlers = new Map();
+    constructor(_type, widget, _props) {
+        if (!isOverlayWidget(widget)) {
+            throw new Error("OverlayNode requires an Overlay widget");
+        }
+        this.widget = widget;
+    }
+    getWidget() {
+        return this.widget;
+    }
+    appendChild(child) {
+        child.attachToParent(this);
+    }
+    removeChild(child) {
+        child.detachFromParent(this);
+    }
+    insertBefore(child, _before) {
+        this.appendChild(child);
+    }
+    attachToParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            appendChild(parentWidget, this.widget);
+        }
+    }
+    detachFromParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            removeChild(parentWidget, this.widget);
+        }
+    }
+    attachChild(childWidget) {
+        if (this.mainChild === null) {
+            this.mainChild = childWidget;
+            this.widget.setChild(childWidget.ptr);
+        }
+        else {
+            this.overlayChildren.push(childWidget);
+            this.widget.addOverlay(childWidget.ptr);
+        }
+    }
+    detachChild(childWidget) {
+        if (this.mainChild === childWidget) {
+            this.widget.setChild(null);
+            this.mainChild = null;
+        }
+        else {
+            const index = this.overlayChildren.indexOf(childWidget);
+            if (index !== -1) {
+                this.overlayChildren.splice(index, 1);
+                this.widget.removeOverlay(childWidget.ptr);
+            }
+        }
+    }
+    updateProps(oldProps, newProps) {
+        const consumedProps = new Set(["children"]);
+        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+        for (const key of allKeys) {
+            if (consumedProps.has(key))
+                continue;
+            const oldValue = oldProps[key];
+            const newValue = newProps[key];
+            if (oldValue === newValue)
+                continue;
+            if (key.startsWith("on")) {
+                const eventName = key
+                    .slice(2)
+                    .replace(/([A-Z])/g, "-$1")
+                    .toLowerCase()
+                    .replace(/^-/, "");
+                const oldHandlerId = this.signalHandlers.get(eventName);
+                if (oldHandlerId !== undefined && isConnectable(this.widget)) {
+                    this.signalHandlers.delete(eventName);
+                }
+                if (typeof newValue === "function" && isConnectable(this.widget)) {
+                    const handlerId = this.widget.connect(eventName, newValue);
+                    this.signalHandlers.set(eventName, handlerId);
+                }
+                continue;
+            }
+            const setterName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+            const setter = this.widget[setterName];
+            if (typeof setter === "function") {
+                setter.call(this.widget, newValue);
+            }
+        }
+    }
+    mount() { }
+    dispose() {
+        disconnectSignalHandlers(this.widget, this.signalHandlers);
+    }
+}

package/dist/nodes/slot.d.ts

@@ -0,0 +1,17 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+export declare class SlotNode implements Node {
+    static needsWidget: boolean;
+    static matches(type: string, _widget: Gtk.Widget | null): _widget is Gtk.Widget;
+    private child;
+    private slotName;
+    constructor(type: string, _widget: Gtk.Widget, _props: Props);
+    appendChild(child: Node): void;
+    removeChild(_child: Node): void;
+    insertBefore(child: Node, _before: Node): void;
+    updateProps(_oldProps: Props, _newProps: Props): void;
+    mount(): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+}

package/dist/nodes/slot.js

@@ -0,0 +1,55 @@
+export class SlotNode {
+    static needsWidget = false;
+    static matches(type, _widget) {
+        if (!type.includes("."))
+            return false;
+        const parts = type.split(".");
+        if (parts.length !== 2)
+            return false;
+        const suffix = parts[1];
+        return suffix !== "Item" && suffix !== "Root";
+    }
+    child = null;
+    slotName;
+    constructor(type, _widget, _props) {
+        const dotIndex = type.indexOf(".");
+        if (dotIndex === -1) {
+            throw new Error(`Invalid slot type: ${type}`);
+        }
+        this.slotName = type.substring(dotIndex + 1);
+    }
+    appendChild(child) {
+        if (child.getWidget) {
+            this.child = child;
+        }
+    }
+    removeChild(_child) {
+        this.child = null;
+    }
+    insertBefore(child, _before) {
+        this.appendChild(child);
+    }
+    updateProps(_oldProps, _newProps) { }
+    mount() { }
+    attachToParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        const childWidget = this.child?.getWidget?.();
+        if (!parentWidget || !childWidget)
+            return;
+        const setterName = `set${this.slotName}`;
+        const setter = parentWidget[setterName];
+        if (typeof setter === "function") {
+            setter.call(parentWidget, childWidget.ptr);
+        }
+    }
+    detachFromParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (!parentWidget)
+            return;
+        const setterName = `set${this.slotName}`;
+        const setter = parentWidget[setterName];
+        if (typeof setter === "function") {
+            setter.call(parentWidget, null);
+        }
+    }
+}

package/dist/nodes/text.d.ts

@@ -0,0 +1,16 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+export declare class TextNode implements Node<Gtk.Label> {
+    private label;
+    constructor(text: string);
+    getWidget(): Gtk.Label;
+    updateText(text: string): void;
+    appendChild(_child: Node): void;
+    removeChild(_child: Node): void;
+    insertBefore(_child: Node, _before: Node): void;
+    updateProps(_oldProps: Props, _newProps: Props): void;
+    mount(): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+}

package/dist/nodes/text.js

@@ -0,0 +1,31 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { appendChild, removeChild } from "../widget-capabilities.js";
+export class TextNode {
+    label;
+    constructor(text) {
+        this.label = new Gtk.Label(text);
+    }
+    getWidget() {
+        return this.label;
+    }
+    updateText(text) {
+        this.label.setLabel(text);
+    }
+    appendChild(_child) { }
+    removeChild(_child) { }
+    insertBefore(_child, _before) { }
+    updateProps(_oldProps, _newProps) { }
+    mount() { }
+    attachToParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            appendChild(parentWidget, this.label);
+        }
+    }
+    detachFromParent(parent) {
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            removeChild(parentWidget, this.label);
+        }
+    }
+}

package/dist/nodes/widget.d.ts

@@ -0,0 +1,19 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+export declare class WidgetNode implements Node {
+    static needsWidget: boolean;
+    static matches(_type: string, widget: Gtk.Widget | null): widget is Gtk.Widget;
+    private widget;
+    private signalHandlers;
+    constructor(_type: string, widget: Gtk.Widget, _props: Props);
+    getWidget(): Gtk.Widget;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    insertBefore(child: Node, _before: Node): void;
+    attachToParent(parent: Node): void;
+    detachFromParent(parent: Node): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+    mount(): void;
+    dispose(): void;
+}

package/dist/nodes/widget.js

@@ -0,0 +1,136 @@
+import * as GObject from "@gtkx/ffi/gobject";
+import { appendChild, disconnectSignalHandlers, isConnectable, isDefaultSizable, isPresentable, removeChild, } from "../widget-capabilities.js";
+import { ActionBarNode } from "./action-bar.js";
+import { NotebookNode } from "./notebook.js";
+import { OverlayNode } from "./overlay.js";
+const COMBINED_PROPS = [
+    {
+        props: ["defaultWidth", "defaultHeight"],
+        apply: (widget) => (values) => {
+            if (isDefaultSizable(widget)) {
+                const width = values.defaultWidth ?? -1;
+                const height = values.defaultHeight ?? -1;
+                widget.setDefaultSize(width, height);
+            }
+        },
+    },
+];
+export class WidgetNode {
+    static needsWidget = true;
+    static matches(_type, widget) {
+        return widget !== null;
+    }
+    widget;
+    signalHandlers = new Map();
+    constructor(_type, widget, _props) {
+        this.widget = widget;
+    }
+    getWidget() {
+        return this.widget;
+    }
+    appendChild(child) {
+        child.attachToParent(this);
+    }
+    removeChild(child) {
+        child.detachFromParent(this);
+    }
+    insertBefore(child, _before) {
+        this.appendChild(child);
+    }
+    attachToParent(parent) {
+        if (parent instanceof NotebookNode) {
+            parent.attachChild(this.widget);
+            return;
+        }
+        if (parent instanceof OverlayNode) {
+            parent.attachChild(this.widget);
+            return;
+        }
+        if (parent instanceof ActionBarNode) {
+            parent.attachChild(this.widget);
+            return;
+        }
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            appendChild(parentWidget, this.widget);
+        }
+    }
+    detachFromParent(parent) {
+        if (parent instanceof NotebookNode) {
+            parent.detachChild(this.widget);
+            return;
+        }
+        if (parent instanceof OverlayNode) {
+            parent.detachChild(this.widget);
+            return;
+        }
+        if (parent instanceof ActionBarNode) {
+            parent.detachChild(this.widget);
+            return;
+        }
+        const parentWidget = parent.getWidget?.();
+        if (parentWidget) {
+            removeChild(parentWidget, this.widget);
+        }
+    }
+    updateProps(oldProps, newProps) {
+        const consumedProps = new Set(["children", "application"]);
+        for (const handler of COMBINED_PROPS) {
+            const hasAnyChanged = handler.props.some((prop) => oldProps[prop] !== newProps[prop]);
+            if (hasAnyChanged) {
+                const values = {};
+                for (const prop of handler.props) {
+                    values[prop] = newProps[prop];
+                    consumedProps.add(prop);
+                }
+                handler.apply(this.widget)(values);
+            }
+            else {
+                for (const prop of handler.props) {
+                    consumedProps.add(prop);
+                }
+            }
+        }
+        const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+        for (const key of allKeys) {
+            if (consumedProps.has(key))
+                continue;
+            const oldValue = oldProps[key];
+            const newValue = newProps[key];
+            if (oldValue === newValue)
+                continue;
+            if (key.startsWith("on")) {
+                const eventName = key
+                    .slice(2)
+                    .replace(/([A-Z])/g, "-$1")
+                    .toLowerCase()
+                    .replace(/^-/, "");
+                const oldHandlerId = this.signalHandlers.get(eventName);
+                if (oldHandlerId !== undefined) {
+                    GObject.signalHandlerDisconnect(this.widget, oldHandlerId);
+                    this.signalHandlers.delete(eventName);
+                }
+                if (typeof newValue === "function" && isConnectable(this.widget)) {
+                    const handlerId = this.widget.connect(eventName, newValue);
+                    this.signalHandlers.set(eventName, handlerId);
+                }
+                continue;
+            }
+            if (newValue === undefined)
+                continue;
+            const setterName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+            const setter = this.widget[setterName];
+            if (typeof setter === "function") {
+                setter.call(this.widget, newValue);
+            }
+        }
+    }
+    mount() {
+        if (isPresentable(this.widget)) {
+            this.widget.present();
+        }
+    }
+    dispose() {
+        disconnectSignalHandlers(this.widget, this.signalHandlers);
+    }
+}

package/dist/portal.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode, ReactPortal } from "react";
+export declare const isRootPortalContainer: (container: unknown) => boolean;
+export declare const createPortal: (children: ReactNode, container?: unknown, key?: string | null) => ReactPortal;

package/dist/portal.js

@@ -0,0 +1,11 @@
+const ROOT_PORTAL_CONTAINER = Symbol("ROOT_PORTAL_CONTAINER");
+export const isRootPortalContainer = (container) => container === ROOT_PORTAL_CONTAINER;
+export const createPortal = (children, container, key) => {
+    return {
+        $$typeof: Symbol.for("react.portal"),
+        key: key ?? null,
+        children,
+        containerInfo: container ?? ROOT_PORTAL_CONTAINER,
+        implementation: null,
+    };
+};

package/dist/reconciler.d.ts

@@ -0,0 +1,20 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Application } from "@gtkx/ffi/gtk";
+import Reconciler from "react-reconciler";
+import type { Node } from "./node.js";
+export declare const getCurrentApp: () => Application | null;
+export declare const getActiveWindow: () => Gtk.Window | null;
+export declare const disposeAllInstances: () => void;
+import { TextNode } from "./nodes/text.js";
+type PublicInstance = Node;
+export declare class GtkReconciler {
+    private reconciler;
+    constructor();
+    setCurrentApp(app: Application): void;
+    getReconciler(): typeof this.reconciler;
+    private createHostConfig;
+    private createReconcilerContext;
+}
+export declare const reconciler: Reconciler.Reconciler<unknown, Node<Gtk.Widget>, TextNode, never, never, PublicInstance>;
+export declare const setCurrentApp: (app: Application) => void;
+export {};

package/dist/reconciler.js

@@ -0,0 +1,111 @@
+import React from "react";
+import Reconciler from "react-reconciler";
+import { createNode } from "./factory.js";
+const allInstances = new Set();
+let currentApp = null;
+export const getCurrentApp = () => currentApp;
+export const getActiveWindow = () => currentApp?.getActiveWindow() ?? null;
+export const disposeAllInstances = () => {
+    for (const instance of allInstances) {
+        instance.dispose?.();
+    }
+    allInstances.clear();
+};
+import { TextNode } from "./nodes/text.js";
+export class GtkReconciler {
+    reconciler;
+    constructor() {
+        this.reconciler = Reconciler(this.createHostConfig());
+    }
+    setCurrentApp(app) {
+        currentApp = app;
+    }
+    getReconciler() {
+        return this.reconciler;
+    }
+    createHostConfig() {
+        return {
+            supportsMutation: true,
+            supportsPersistence: false,
+            supportsHydration: false,
+            isPrimaryRenderer: true,
+            noTimeout: -1,
+            getRootHostContext: () => ({}),
+            getChildHostContext: (parentHostContext) => parentHostContext,
+            shouldSetTextContent: () => false,
+            createInstance: (type, props) => {
+                const instance = createNode(type, props, currentApp);
+                allInstances.add(instance);
+                return instance;
+            },
+            createTextInstance: (text) => {
+                return new TextNode(text);
+            },
+            appendInitialChild: (parent, child) => parent.appendChild(child),
+            finalizeInitialChildren: () => true,
+            commitUpdate: (instance, _type, oldProps, newProps) => {
+                instance.updateProps(oldProps, newProps);
+            },
+            commitMount: (instance) => {
+                instance.mount();
+            },
+            appendChild: (parent, child) => parent.appendChild(child),
+            removeChild: (parent, child) => parent.removeChild(child),
+            insertBefore: (parent, child, beforeChild) => parent.insertBefore(child, beforeChild),
+            removeChildFromContainer: (_container, _child) => { },
+            appendChildToContainer: (_container, child) => {
+                child.mount();
+            },
+            insertInContainerBefore: (_container, child, _beforeChild) => {
+                child.mount();
+            },
+            prepareForCommit: () => null,
+            resetAfterCommit: () => { },
+            commitTextUpdate: (textInstance, _oldText, newText) => {
+                textInstance.updateText(newText);
+            },
+            clearContainer: () => { },
+            preparePortalMount: () => { },
+            scheduleTimeout: (fn, delay) => {
+                const timeoutId = setTimeout(fn, delay ?? 0);
+                return typeof timeoutId === "number" ? timeoutId : Number(timeoutId);
+            },
+            cancelTimeout: (id) => {
+                clearTimeout(id);
+            },
+            getPublicInstance: (instance) => instance,
+            getCurrentUpdatePriority: () => 2,
+            setCurrentUpdatePriority: () => { },
+            resolveUpdatePriority: () => 2,
+            NotPendingTransition: null,
+            HostTransitionContext: this.createReconcilerContext(0),
+            getInstanceFromNode: () => null,
+            beforeActiveInstanceBlur: () => { },
+            afterActiveInstanceBlur: () => { },
+            prepareScopeUpdate: () => { },
+            getInstanceFromScope: () => null,
+            detachDeletedInstance: (instance) => {
+                instance.dispose?.();
+                allInstances.delete(instance);
+            },
+            resetFormInstance: () => { },
+            requestPostPaintCallback: () => { },
+            shouldAttemptEagerTransition: () => false,
+            trackSchedulerEvent: () => { },
+            resolveEventType: () => null,
+            resolveEventTimeStamp: () => Date.now(),
+            maySuspendCommit: () => false,
+            preloadInstance: () => false,
+            startSuspendingCommit: () => { },
+            suspendInstance: () => { },
+            waitForCommitToBeReady: () => null,
+        };
+    }
+    createReconcilerContext(value) {
+        const context = React.createContext(value);
+        return context;
+    }
+}
+const gtkReconciler = new GtkReconciler();
+export const reconciler = gtkReconciler.getReconciler();
+export const setCurrentApp = (app) => gtkReconciler.setCurrentApp(app);

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationFlags } from "@gtkx/ffi/gio";
+import type { Application } from "@gtkx/ffi/gtk";
+import type { ReactNode } from "react";
+export declare let container: unknown;
+export declare const render: (element: ReactNode, appId: string, flags?: ApplicationFlags) => Application;

package/dist/render.js

@@ -0,0 +1,12 @@
+import { start } from "@gtkx/ffi";
+import { reconciler, setCurrentApp } from "./reconciler.js";
+export let container = null;
+export const render = (element, appId, flags) => {
+    const app = start(appId, flags);
+    setCurrentApp(app);
+    container = reconciler.createContainer(appId, 0, null, false, false, "", (error, info) => {
+        console.error("React reconciler error:", error, info);
+    }, null, null, null, null);
+    reconciler.updateContainer(element, container, null, () => { });
+    return app;
+};

package/dist/signal-utils.d.ts

@@ -0,0 +1,4 @@
+import * as GObject from "@gtkx/ffi/gobject";
+type SignalHandlerMap = Map<string, number>;
+export declare const disconnectSignalHandlers: (gobject: GObject.GObject, handlers: SignalHandlerMap) => void;
+export {};

package/dist/signal-utils.js

@@ -0,0 +1,7 @@
+import * as GObject from "@gtkx/ffi/gobject";
+export const disconnectSignalHandlers = (gobject, handlers) => {
+    for (const handlerId of handlers.values()) {
+        GObject.signalHandlerDisconnect(gobject, handlerId);
+    }
+    handlers.clear();
+};

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export interface SlotProps {
+    children?: ReactNode;
+}
+export interface ItemProps<T> {
+    item: T;
+}
+export interface GridChildProps extends SlotProps {
+    column?: number;
+    row?: number;
+    columnSpan?: number;
+    rowSpan?: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/widget-capabilities.d.ts

@@ -0,0 +1,46 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+export interface Appendable extends Gtk.Widget {
+    append(child: unknown): void;
+}
+export interface SingleChild extends Gtk.Widget {
+    setChild(child: unknown): void;
+}
+export interface Removable extends Gtk.Widget {
+    remove(child: unknown): void;
+}
+export interface Presentable extends Gtk.Widget {
+    present(): void;
+}
+export interface Connectable extends Gtk.Widget {
+    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+}
+export interface DefaultSizable extends Gtk.Widget {
+    setDefaultSize(width: number, height: number): void;
+}
+export interface ModelSettable extends Gtk.Widget {
+    setModel(model: unknown): void;
+}
+export interface Selectable extends Gtk.Widget {
+    getSelected(): number;
+}
+export interface GridAttachable extends Gtk.Widget {
+    attach(child: unknown, column: number, row: number, width: number, height: number): void;
+}
+export interface NotebookLike extends Gtk.Widget {
+    appendPage(child: unknown, tabLabel?: unknown): number;
+    pageNum(child: unknown): number;
+    removePage(pageNum: number): void;
+}
+export declare const isAppendable: (widget: Gtk.Widget) => widget is Appendable;
+export declare const isSingleChild: (widget: Gtk.Widget) => widget is SingleChild;
+export declare const isRemovable: (widget: Gtk.Widget) => widget is Removable;
+export declare const isPresentable: (widget: Gtk.Widget) => widget is Presentable;
+export declare const isConnectable: (widget: Gtk.Widget) => widget is Connectable;
+export declare const isDefaultSizable: (widget: Gtk.Widget) => widget is DefaultSizable;
+export declare const isModelSettable: (widget: Gtk.Widget) => widget is ModelSettable;
+export declare const isSelectable: (widget: Gtk.Widget) => widget is Selectable;
+export declare const isGridAttachable: (widget: Gtk.Widget) => widget is GridAttachable;
+export declare const isNotebookLike: (widget: Gtk.Widget) => widget is NotebookLike;
+export declare const appendChild: (parent: Gtk.Widget, child: Gtk.Widget) => void;
+export declare const removeChild: (parent: Gtk.Widget, child: Gtk.Widget) => void;
+export { disconnectSignalHandlers } from "./signal-utils.js";

package/dist/widget-capabilities.js

@@ -0,0 +1,32 @@
+export const isAppendable = (widget) => "append" in widget && typeof widget.append === "function";
+export const isSingleChild = (widget) => "setChild" in widget && typeof widget.setChild === "function";
+export const isRemovable = (widget) => "remove" in widget && typeof widget.remove === "function";
+export const isPresentable = (widget) => "present" in widget && typeof widget.present === "function";
+export const isConnectable = (widget) => "connect" in widget && typeof widget.connect === "function";
+export const isDefaultSizable = (widget) => "setDefaultSize" in widget && typeof widget.setDefaultSize === "function";
+export const isModelSettable = (widget) => "setModel" in widget && typeof widget.setModel === "function";
+export const isSelectable = (widget) => "getSelected" in widget && typeof widget.getSelected === "function";
+export const isGridAttachable = (widget) => "attach" in widget && typeof widget.attach === "function";
+export const isNotebookLike = (widget) => "appendPage" in widget &&
+    typeof widget.appendPage === "function" &&
+    "pageNum" in widget &&
+    typeof widget.pageNum === "function" &&
+    "removePage" in widget &&
+    typeof widget.removePage === "function";
+export const appendChild = (parent, child) => {
+    if (isSingleChild(parent)) {
+        parent.setChild(child.ptr);
+    }
+    else if (isAppendable(parent)) {
+        parent.append(child.ptr);
+    }
+};
+export const removeChild = (parent, child) => {
+    if (isRemovable(parent)) {
+        parent.remove(child.ptr);
+    }
+    else if (isSingleChild(parent)) {
+        parent.setChild(null);
+    }
+};
+export { disconnectSignalHandlers } from "./signal-utils.js";