@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/text-tag.js

@@ -1,22 +1,107 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { applyStyleChanges } from "./internal/text-tag-styles.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
 import { TextAnchorNode } from "./text-anchor.js";
-import { TextSegmentNode } from "./text-segment.js";
+import { isTextContentParent, TextSegmentNode } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
+const STYLE_PROPS = {
+    background: "setBackground",
+    backgroundFullHeight: "setBackgroundFullHeight",
+    foreground: "setForeground",
+    family: "setFamily",
+    font: "setFont",
+    sizePoints: "setSizePoints",
+    size: "setSize",
+    scale: "setScale",
+    weight: "setWeight",
+    style: "setStyle",
+    stretch: "setStretch",
+    variant: "setVariant",
+    strikethrough: "setStrikethrough",
+    underline: "setUnderline",
+    overline: "setOverline",
+    rise: "setRise",
+    letterSpacing: "setLetterSpacing",
+    lineHeight: "setLineHeight",
+    leftMargin: "setLeftMargin",
+    rightMargin: "setRightMargin",
+    indent: "setIndent",
+    pixelsAboveLines: "setPixelsAboveLines",
+    pixelsBelowLines: "setPixelsBelowLines",
+    pixelsInsideWrap: "setPixelsInsideWrap",
+    justification: "setJustification",
+    direction: "setDirection",
+    wrapMode: "setWrapMode",
+    editable: "setEditable",
+    invisible: "setInvisible",
+    allowBreaks: "setAllowBreaks",
+    insertHyphens: "setInsertHyphens",
+    fallback: "setFallback",
+    accumulativeMargin: "setAccumulativeMargin",
+    paragraphBackground: "setParagraphBackground",
+    showSpaces: "setShowSpaces",
+    textTransform: "setTextTransform",
+    fontFeatures: "setFontFeatures",
+    language: "setLanguage",
+};
 export class TextTagNode extends VirtualNode {
-    static priority = 1;
     buffer = null;
     tag = null;
-    children = [];
-    parent = null;
     bufferOffset = 0;
-    static matches(type) {
-        return type === "TextTag";
+    getBufferOffset() {
+        return this.bufferOffset;
     }
-    setParent(parent) {
-        this.parent = parent;
+    setBufferOffset(offset) {
+        this.bufferOffset = offset;
+    }
+    isValidChild(child) {
+        return this.isTextContentChild(child);
+    }
+    isValidParent(parent) {
+        return isTextContentParent(parent);
+    }
+    appendChild(child) {
+        const index = this.children.length;
+        super.appendChild(child);
+        if (child instanceof TextTagNode && this.buffer) {
+            child.setBuffer(this.buffer);
+        }
+        this.updateChildOffsets(index);
+        this.parent?.onChildInserted(child);
+    }
+    removeChild(child) {
+        const index = this.children.indexOf(child);
+        if (index !== -1) {
+            this.children.splice(index, 1);
+            child.setParent(null);
+            this.updateChildOffsets(index);
+            this.parent?.onChildRemoved(child);
+            return;
+        }
+        super.removeChild(child);
+    }
+    insertBefore(child, before) {
+        const beforeIndex = this.children.indexOf(before);
+        const insertIndex = beforeIndex !== -1 ? beforeIndex : this.children.length;
+        super.insertBefore(child, before);
+        if (child instanceof TextTagNode && this.buffer) {
+            child.setBuffer(this.buffer);
+        }
+        this.updateChildOffsets(insertIndex);
+        this.parent?.onChildInserted(child);
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+    detachDeletedInstance() {
+        if (this.buffer && this.tag) {
+            this.removeTagFromBuffer();
+            const tagTable = this.buffer.getTagTable();
+            tagTable.remove(this.tag);
+        }
+        this.tag = null;
+        this.buffer = null;
+        super.detachDeletedInstance();
     }
     setBuffer(buffer) {
         this.buffer = buffer;
@@ -31,6 +116,43 @@ export class TextTagNode extends VirtualNode {
     hasBuffer() {
         return this.buffer !== null;
     }
+    getText() {
+        let text = "";
+        for (const child of this.children) {
+            text += child.getText();
+        }
+        return text;
+    }
+    getLength() {
+        let length = 0;
+        for (const child of this.children) {
+            length += child.getLength();
+        }
+        return length;
+    }
+    reapplyTag() {
+        if (!this.buffer || !this.tag)
+            return;
+        this.removeTagFromBuffer();
+        this.applyTagToRange();
+    }
+    onChildInserted(child) {
+        const index = this.children.indexOf(child);
+        if (index !== -1) {
+            this.updateChildOffsets(index);
+        }
+        this.parent?.onChildInserted(child);
+    }
+    onChildRemoved(child) {
+        this.parent?.onChildRemoved(child);
+    }
+    onChildTextChanged(child, oldLength, newLength) {
+        const index = this.children.indexOf(child);
+        if (index !== -1) {
+            this.updateChildOffsets(index + 1);
+        }
+        this.parent?.onChildTextChanged(child, oldLength, newLength);
+    }
     setupTag() {
         if (!this.buffer)
             return;
@@ -43,27 +165,30 @@ export class TextTagNode extends VirtualNode {
         }
         this.applyTagToRange();
     }
-    applyStyleProps(oldProps, newProps) {
+    applyOwnProps(oldProps, newProps) {
+        if (oldProps && oldProps.id !== newProps.id) {
+            throw new Error("TextTag id cannot be changed after creation");
+        }
         if (!this.tag)
             return;
-        applyStyleChanges(this.tag, oldProps, newProps);
-    }
-    getText() {
-        let text = "";
-        for (const child of this.children) {
-            text += child.getText();
+        this.applyStyleProps(oldProps, newProps);
+        if (hasChanged(oldProps, newProps, "priority") && newProps.priority !== undefined) {
+            this.tag.setPriority(newProps.priority);
         }
-        return text;
     }
-    getLength() {
-        let length = 0;
-        for (const child of this.children) {
-            length += child.getLength();
+    applyStyleProps(oldProps, newProps) {
+        if (!this.tag)
+            return;
+        for (const prop of Object.keys(STYLE_PROPS)) {
+            if (hasChanged(oldProps, newProps, prop)) {
+                const value = newProps[prop];
+                const method = STYLE_PROPS[prop];
+                if (value !== undefined && method) {
+                    const setter = this.tag[method];
+                    setter.call(this.tag, value);
+                }
+            }
         }
-        return length;
-    }
-    getChildren() {
-        return this.children;
     }
     applyTagToRange() {
         const buffer = this.buffer;
@@ -90,12 +215,6 @@ export class TextTagNode extends VirtualNode {
         buffer.getEndIter(endIter);
         buffer.removeTag(tag, startIter, endIter);
     }
-    reapplyTag() {
-        if (!this.buffer || !this.tag)
-            return;
-        this.removeTagFromBuffer();
-        this.applyTagToRange();
-    }
     updateChildOffsets(startIndex) {
         let offset = this.bufferOffset;
         for (let i = 0; i < startIndex; i++) {
@@ -106,97 +225,12 @@ export class TextTagNode extends VirtualNode {
         for (let i = startIndex; i < this.children.length; i++) {
             const child = this.children[i];
             if (child) {
-                child.bufferOffset = offset;
+                child.setBufferOffset(offset);
                 offset += child.getLength();
             }
         }
     }
-    onChildInserted(child) {
-        const index = this.children.indexOf(child);
-        if (index !== -1) {
-            this.updateChildOffsets(index);
-        }
-        this.parent?.onChildInserted(child);
-    }
-    onChildRemoved(child) {
-        this.parent?.onChildRemoved(child);
-    }
-    onChildTextChanged(child, oldLength, newLength) {
-        const index = this.children.indexOf(child);
-        if (index !== -1) {
-            this.updateChildOffsets(index + 1);
-        }
-        this.parent?.onChildTextChanged(child, oldLength, newLength);
-    }
-    appendChild(child) {
-        if (this.isTextContentChild(child)) {
-            const index = this.children.length;
-            this.children.push(child);
-            this.setChildParent(child);
-            if (child instanceof TextTagNode && this.buffer) {
-                child.setBuffer(this.buffer);
-            }
-            this.updateChildOffsets(index);
-            this.parent?.onChildInserted(child);
-            return;
-        }
-        super.appendChild(child);
-    }
-    removeChild(child) {
-        const index = this.children.indexOf(child);
-        if (index !== -1) {
-            this.children.splice(index, 1);
-            this.updateChildOffsets(index);
-            this.parent?.onChildRemoved(child);
-            return;
-        }
-        super.removeChild(child);
-    }
-    insertBefore(child, before) {
-        if (this.isTextContentChild(child)) {
-            const beforeIndex = this.children.indexOf(before);
-            const insertIndex = beforeIndex !== -1 ? beforeIndex : this.children.length;
-            this.children.splice(insertIndex, 0, child);
-            this.setChildParent(child);
-            if (child instanceof TextTagNode && this.buffer) {
-                child.setBuffer(this.buffer);
-            }
-            this.updateChildOffsets(insertIndex);
-            this.parent?.onChildInserted(child);
-            return;
-        }
-        super.insertBefore(child, before);
-    }
     isTextContentChild(child) {
         return child instanceof TextSegmentNode || child instanceof TextTagNode || child instanceof TextAnchorNode;
     }
-    setChildParent(child) {
-        if (child instanceof TextSegmentNode || child instanceof TextTagNode) {
-            child.setParent(this);
-        }
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (oldProps && oldProps.id !== newProps.id) {
-            throw new Error("TextTag id cannot be changed after creation");
-        }
-        if (this.tag) {
-            this.applyStyleProps(oldProps, newProps);
-            if (hasChanged(oldProps, newProps, "priority") && newProps.priority !== undefined) {
-                this.tag.setPriority(newProps.priority);
-            }
-        }
-    }
-    unmount() {
-        if (this.buffer && this.tag) {
-            this.removeTagFromBuffer();
-            const tagTable = this.buffer.getTagTable();
-            tagTable.remove(this.tag);
-        }
-        this.tag = null;
-        this.buffer = null;
-        this.children = [];
-        super.unmount();
-    }
 }
-registerNodeClass(TextTagNode);

package/dist/nodes/text-view.d.ts

@@ -1,29 +1,24 @@
 import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkTextViewProps } from "../jsx.js";
 import type { Node } from "../node.js";
-import type { Container, ContainerClass, Props } from "../types.js";
+import { EventControllerNode } from "./event-controller.js";
 import { TextBufferController } from "./internal/text-buffer-controller.js";
+import { SlotNode } from "./slot.js";
 import type { TextContentChild, TextContentParent } from "./text-content.js";
-import type { TextSegmentNode } from "./text-segment.js";
+import { TextSegmentNode } from "./text-segment.js";
 import { WidgetNode } from "./widget.js";
-type TextViewProps = Props & {
-    enableUndo?: boolean;
-    onBufferChanged?: ((buffer: Gtk.TextBuffer) => void) | null;
-    onTextInserted?: ((buffer: Gtk.TextBuffer, offset: number, text: string) => void) | null;
-    onTextDeleted?: ((buffer: Gtk.TextBuffer, startOffset: number, endOffset: number) => void) | null;
-    onCanUndoChanged?: ((canUndo: boolean) => void) | null;
-    onCanRedoChanged?: ((canRedo: boolean) => void) | null;
-};
-export declare class TextViewNode extends WidgetNode<Gtk.TextView, TextViewProps> implements TextContentParent {
-    static priority: number;
+declare const OWN_PROPS: readonly ["enableUndo", "onBufferChanged", "onTextInserted", "onTextDeleted", "onCanUndoChanged", "onCanRedoChanged"];
+type TextViewProps = Pick<GtkTextViewProps, (typeof OWN_PROPS)[number]>;
+type TextViewChild = TextContentChild | SlotNode | EventControllerNode | WidgetNode;
+export declare class TextViewNode extends WidgetNode<Gtk.TextView, TextViewProps, TextViewChild> implements TextContentParent {
     protected bufferController: TextBufferController | null;
-    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
+    isValidChild(child: Node): boolean;
     protected ensureBufferController(): TextBufferController;
     protected createBufferController(): TextBufferController;
-    updateProps(oldProps: TextViewProps | null, newProps: TextViewProps): void;
-    protected applyOwnProps(oldProps: TextViewProps | null, newProps: TextViewProps): void;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
+    commitUpdate(oldProps: TextViewProps | null, newProps: TextViewProps): void;
+    appendChild(child: TextViewChild): void;
+    insertBefore(child: TextViewChild, before: TextViewChild): void;
+    removeChild(child: TextViewChild): void;
     onChildInserted(child: TextContentChild): void;
     onChildRemoved(child: TextContentChild): void;
     onChildTextChanged(child: TextSegmentNode, oldLength: number, newLength: number): void;

package/dist/nodes/text-view.js

@@ -1,8 +1,12 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import * as GtkSource from "@gtkx/ffi/gtksource";
-import { registerNodeClass } from "../registry.js";
+import { EventControllerNode } from "./event-controller.js";
+import { filterProps } from "./internal/props.js";
 import { TextBufferController } from "./internal/text-buffer-controller.js";
-import { filterProps, matchesAnyClass } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
+import { TextAnchorNode } from "./text-anchor.js";
+import { TextPaintableNode } from "./text-paintable.js";
+import { TextSegmentNode } from "./text-segment.js";
+import { TextTagNode } from "./text-tag.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = [
     "enableUndo",
@@ -13,12 +17,15 @@ const OWN_PROPS = [
     "onCanRedoChanged",
 ];
 export class TextViewNode extends WidgetNode {
-    static priority = 1;
     bufferController = null;
-    static matches(_type, containerOrClass) {
-        if (matchesAnyClass([GtkSource.View], containerOrClass))
-            return false;
-        return matchesAnyClass([Gtk.TextView], containerOrClass);
+    isValidChild(child) {
+        return (child instanceof TextSegmentNode ||
+            child instanceof TextTagNode ||
+            child instanceof TextAnchorNode ||
+            child instanceof TextPaintableNode ||
+            child instanceof SlotNode ||
+            child instanceof EventControllerNode ||
+            child instanceof WidgetNode);
     }
     ensureBufferController() {
         if (!this.bufferController) {
@@ -29,18 +36,14 @@ export class TextViewNode extends WidgetNode {
     createBufferController() {
         return new TextBufferController(this, this.container, () => new Gtk.TextBuffer());
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
-    }
-    applyOwnProps(oldProps, newProps) {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.ensureBufferController().applyOwnProps(oldProps, newProps);
     }
     appendChild(child) {
         const controller = this.ensureBufferController();
         if (controller.isTextContentChild(child)) {
             controller.appendChild(child);
-            return;
         }
         super.appendChild(child);
     }
@@ -48,7 +51,6 @@ export class TextViewNode extends WidgetNode {
         const controller = this.ensureBufferController();
         if (controller.isTextContentChild(child)) {
             controller.insertBefore(child, before);
-            return;
         }
         super.insertBefore(child, before);
     }
@@ -56,7 +58,6 @@ export class TextViewNode extends WidgetNode {
         const controller = this.ensureBufferController();
         if (controller.isTextContentChild(child)) {
             controller.removeChild(child);
-            return;
         }
         super.removeChild(child);
     }
@@ -70,4 +71,3 @@ export class TextViewNode extends WidgetNode {
         this.ensureBufferController().onChildTextChanged(child, oldLength, newLength);
     }
 }
-registerNodeClass(TextViewNode);

package/dist/nodes/toggle-group.d.ts

@@ -1 +1,10 @@
+import type * as Adw from "@gtkx/ffi/adw";
+import type { AdwToggleGroupProps } from "../jsx.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["onActiveChanged"];
+type ToggleGroupProps = Pick<AdwToggleGroupProps, (typeof OWN_PROPS)[number]>;
+export declare class ToggleGroupNode extends WidgetNode<Adw.ToggleGroup, ToggleGroupProps> {
+    commitUpdate(oldProps: ToggleGroupProps | null, newProps: ToggleGroupProps): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/toggle-group.js

@@ -1,40 +1,15 @@
-import * as Adw from "@gtkx/ffi/adw";
-import { registerNodeClass } from "../registry.js";
-import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = ["onActiveChanged"];
-class ToggleGroupNode extends WidgetNode {
-    static priority = 1;
-    notifyHandler = null;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Adw.ToggleGroup], containerOrClass);
+export class ToggleGroupNode extends WidgetNode {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+    applyOwnProps(oldProps, newProps) {
         if (hasChanged(oldProps, newProps, "onActiveChanged")) {
-            this.setupNotifyHandler(newProps.onActiveChanged);
+            const callback = newProps.onActiveChanged;
+            this.signalStore.set(this, this.container, "notify::active", callback ? () => callback(this.container.getActive(), this.container.getActiveName()) : undefined);
         }
     }
-    setupNotifyHandler(callback) {
-        if (this.notifyHandler) {
-            this.signalStore.set(this, this.container, "notify", undefined);
-            this.notifyHandler = null;
-        }
-        if (callback) {
-            this.notifyHandler = (pspec) => {
-                if (pspec.getName() === "active") {
-                    callback(this.container.getActive(), this.container.getActiveName());
-                }
-            };
-            this.signalStore.set(this, this.container, "notify", this.notifyHandler);
-        }
-    }
-    unmount() {
-        if (this.notifyHandler) {
-            this.signalStore.set(this, this.container, "notify", undefined);
-            this.notifyHandler = null;
-        }
-        super.unmount();
-    }
 }
-registerNodeClass(ToggleGroupNode);

package/dist/nodes/toggle.d.ts

@@ -1 +1,15 @@
-export {};
+import * as Adw from "@gtkx/ffi/adw";
+import type { ToggleProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class ToggleNode extends VirtualNode<ToggleProps, WidgetNode<Adw.ToggleGroup>, never> {
+    private toggle;
+    isValidChild(_child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<Adw.ToggleGroup> | null): void;
+    commitUpdate(oldProps: ToggleProps | null, newProps: ToggleProps): void;
+    detachDeletedInstance(): void;
+    private removeFromGroup;
+    private applyOwnProps;
+}

package/dist/nodes/toggle.js

@@ -1,78 +1,60 @@
 import * as Adw from "@gtkx/ffi/adw";
-import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
-class ToggleNode extends VirtualNode {
-    static priority = 1;
-    toggleGroup = null;
+export class ToggleNode extends VirtualNode {
     toggle = null;
-    static matches(type) {
-        return type === "Toggle";
+    isValidChild(_child) {
+        return false;
     }
-    canBeChildOf(parent) {
+    isValidParent(parent) {
         return parent instanceof WidgetNode && parent.container instanceof Adw.ToggleGroup;
     }
-    attachTo(parent) {
-        if (!(parent instanceof WidgetNode) || !(parent.container instanceof Adw.ToggleGroup)) {
-            return;
+    setParent(parent) {
+        if (!parent && this.parent) {
+            this.removeFromGroup();
         }
-        if (this.toggle)
-            return;
-        this.toggleGroup = parent.container;
-        const toggleGroup = this.toggleGroup;
-        this.toggle = new Adw.Toggle();
-        scheduleAfterCommit(() => {
-            const toggle = this.toggle;
-            if (toggle) {
-                this.applyOwnProps(null, this.props);
-                toggleGroup.add(toggle);
-            }
-        }, CommitPriority.NORMAL);
+        super.setParent(parent);
+        if (parent && !this.toggle) {
+            this.toggle = new Adw.Toggle();
+            this.applyOwnProps(null, this.props);
+            parent.container.add(this.toggle);
+        }
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
     }
-    detachFrom(_parent) {
+    detachDeletedInstance() {
         this.removeFromGroup();
+        super.detachDeletedInstance();
     }
     removeFromGroup() {
-        if (!this.toggleGroup || !this.toggle)
+        if (!this.parent || !this.toggle)
             return;
-        const toggleGroup = this.toggleGroup;
-        const toggle = this.toggle;
+        this.parent.container.remove(this.toggle);
         this.toggle = null;
-        scheduleAfterCommit(() => {
-            toggleGroup.remove(toggle);
-        }, CommitPriority.HIGH);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
     }
     applyOwnProps(oldProps, newProps) {
         if (!this.toggle)
             return;
-        if (hasChanged(oldProps, newProps, "id") && newProps.id !== undefined) {
-            this.toggle.setName(newProps.id);
+        if (hasChanged(oldProps, newProps, "id")) {
+            this.toggle.setName(newProps.id ?? "");
         }
-        if (hasChanged(oldProps, newProps, "label") && newProps.label !== undefined) {
-            this.toggle.setLabel(newProps.label);
+        if (hasChanged(oldProps, newProps, "label")) {
+            this.toggle.setLabel(newProps.label ?? "");
         }
-        if (hasChanged(oldProps, newProps, "iconName") && newProps.iconName !== undefined) {
-            this.toggle.setIconName(newProps.iconName);
+        if (hasChanged(oldProps, newProps, "iconName")) {
+            this.toggle.setIconName(newProps.iconName ?? "");
         }
-        if (hasChanged(oldProps, newProps, "tooltip") && newProps.tooltip !== undefined) {
-            this.toggle.setTooltip(newProps.tooltip);
+        if (hasChanged(oldProps, newProps, "tooltip")) {
+            this.toggle.setTooltip(newProps.tooltip ?? "");
         }
-        if (hasChanged(oldProps, newProps, "enabled") && newProps.enabled !== undefined) {
-            this.toggle.setEnabled(newProps.enabled);
+        if (hasChanged(oldProps, newProps, "enabled")) {
+            this.toggle.setEnabled(newProps.enabled ?? true);
         }
-        if (hasChanged(oldProps, newProps, "useUnderline") && newProps.useUnderline !== undefined) {
-            this.toggle.setUseUnderline(newProps.useUnderline);
+        if (hasChanged(oldProps, newProps, "useUnderline")) {
+            this.toggle.setUseUnderline(newProps.useUnderline ?? false);
         }
     }
-    unmount() {
-        this.removeFromGroup();
-        super.unmount();
-    }
 }
-registerNodeClass(ToggleNode);

package/dist/nodes/virtual.d.ts

@@ -1,13 +1,6 @@
 import { Node } from "../node.js";
-import type { Container, Props } from "../types.js";
-export declare class VirtualNode<P = Props> extends Node<undefined, P> {
-    static priority: number;
-    static matches(_type: string): boolean;
+import type { Container } from "../types.js";
+export declare class VirtualNode<TProps = any, TParent extends Node = any, TChild extends Node = any> extends Node<undefined, TProps, TParent, TChild> {
     static createContainer(): void;
-    props: P;
-    constructor(typeName: string, props: P | undefined, container: undefined, rootContainer: Container);
-    appendChild(_child: Node): void;
-    removeChild(_child: Node): void;
-    insertBefore(_child: Node, _before: Node): void;
-    updateProps(_oldProps: P | null, newProps: P): void;
+    constructor(typeName: string, props: TProps | undefined, container: undefined, rootContainer: Container);
 }

package/dist/nodes/virtual.js

@@ -1,21 +1,8 @@
 import { Node } from "../node.js";
-import { registerNodeClass } from "../registry.js";
+// biome-ignore lint/suspicious/noExplicitAny: Self-referential type bounds require any
 export class VirtualNode extends Node {
-    static priority = 1;
-    static matches(_type) {
-        return false;
-    }
     static createContainer() { }
-    props;
     constructor(typeName, props = {}, container, rootContainer) {
         super(typeName, props, container, rootContainer);
-        this.props = props;
-    }
-    appendChild(_child) { }
-    removeChild(_child) { }
-    insertBefore(_child, _before) { }
-    updateProps(_oldProps, newProps) {
-        this.props = newProps;
     }
 }
-registerNodeClass(VirtualNode);