@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/scale.js

@@ -1,18 +1,10 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
 import { AdjustableNode } from "./adjustable.js";
-import { matchesAnyClass, shallowArrayEqual } from "./internal/utils.js";
-class ScaleNode extends AdjustableNode {
-    static priority = 1;
+import { shallowArrayEqual } from "./internal/props.js";
+export class ScaleNode extends AdjustableNode {
     appliedMarks = [];
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.Scale], containerOrClass);
-    }
     applyOwnProps(oldProps, newProps) {
         super.applyOwnProps(oldProps, newProps);
-        this.applyMarks(newProps);
-    }
-    applyMarks(newProps) {
         const newMarks = newProps.marks ?? [];
         if (shallowArrayEqual(this.appliedMarks, newMarks)) {
             return;
@@ -24,4 +16,3 @@ class ScaleNode extends AdjustableNode {
         this.appliedMarks = [...newMarks];
     }
 }
-registerNodeClass(ScaleNode);

package/dist/nodes/scrolled-window.d.ts

@@ -1 +1,10 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkScrolledWindowProps } from "../jsx.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["hscrollbarPolicy", "vscrollbarPolicy"];
+type ScrolledWindowProps = Pick<GtkScrolledWindowProps, (typeof OWN_PROPS)[number]>;
+export declare class ScrolledWindowNode extends WidgetNode<Gtk.ScrolledWindow, ScrolledWindowProps> {
+    commitUpdate(oldProps: ScrolledWindowProps | null, newProps: ScrolledWindowProps): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/scrolled-window.js

@@ -1,15 +1,10 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-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 PROPS = ["hscrollbarPolicy", "vscrollbarPolicy"];
-class ScrolledWindowNode extends WidgetNode {
-    static priority = 2;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.ScrolledWindow], containerOrClass);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, PROPS) : null, filterProps(newProps, PROPS));
+const OWN_PROPS = ["hscrollbarPolicy", "vscrollbarPolicy"];
+export class ScrolledWindowNode extends WidgetNode {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.applyOwnProps(oldProps, newProps);
     }
     applyOwnProps(oldProps, newProps) {
@@ -20,4 +15,3 @@ class ScrolledWindowNode extends WidgetNode {
         }
     }
 }
-registerNodeClass(ScrolledWindowNode);

package/dist/nodes/search-bar.d.ts

@@ -1 +1,10 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkSearchBarProps } from "../jsx.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["onSearchModeChanged"];
+type SearchBarProps = Pick<GtkSearchBarProps, (typeof OWN_PROPS)[number]>;
+export declare class SearchBarNode extends WidgetNode<Gtk.SearchBar, SearchBarProps> {
+    commitUpdate(oldProps: SearchBarProps | null, newProps: SearchBarProps): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/search-bar.js

@@ -1,40 +1,15 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-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 = ["onSearchModeChanged"];
-class SearchBarNode extends WidgetNode {
-    static priority = 1;
-    notifyHandler = null;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.SearchBar], containerOrClass);
+export class SearchBarNode 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, "onSearchModeChanged")) {
-            this.setupNotifyHandler(newProps.onSearchModeChanged);
+            const callback = newProps.onSearchModeChanged;
+            this.signalStore.set(this, this.container, "notify::search-mode-enabled", callback ? () => callback(this.container.getSearchMode()) : undefined);
         }
     }
-    setupNotifyHandler(callback) {
-        if (this.notifyHandler) {
-            this.signalStore.set(this, this.container, "notify", undefined);
-            this.notifyHandler = null;
-        }
-        if (callback) {
-            this.notifyHandler = (_searchBar, pspec) => {
-                if (pspec.getName() === "search-mode-enabled") {
-                    callback(this.container.getSearchMode());
-                }
-            };
-            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(SearchBarNode);

package/dist/nodes/shortcut-controller.d.ts

@@ -1 +1,9 @@
-export {};
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import { EventControllerNode } from "./event-controller.js";
+import { ShortcutNode } from "./shortcut.js";
+export declare class ShortcutControllerNode extends EventControllerNode<Gtk.ShortcutController, ShortcutNode> {
+    isValidChild(child: Node): boolean;
+    appendChild(child: ShortcutNode): void;
+    removeChild(child: ShortcutNode): void;
+}

package/dist/nodes/shortcut-controller.js

@@ -1,35 +1,22 @@
-import { registerNodeClass } from "../registry.js";
 import { EventControllerNode } from "./event-controller.js";
 import { ShortcutNode } from "./shortcut.js";
-class ShortcutControllerNode extends EventControllerNode {
-    static priority = 0;
-    static matches(type) {
-        return type === "GtkShortcutController";
+export class ShortcutControllerNode extends EventControllerNode {
+    isValidChild(child) {
+        return child instanceof ShortcutNode;
     }
-    shortcuts = [];
     appendChild(child) {
-        if (!(child instanceof ShortcutNode)) {
-            throw new Error(`ShortcutController only accepts Shortcut children, got '${child.typeName}'`);
+        super.appendChild(child);
+        child.createShortcut();
+        const shortcut = child.getShortcut();
+        if (shortcut) {
+            this.container.addShortcut(shortcut);
         }
-        this.shortcuts.push(child);
-        this.addShortcutToController(child);
     }
     removeChild(child) {
-        if (!(child instanceof ShortcutNode))
-            return;
-        const index = this.shortcuts.indexOf(child);
-        if (index !== -1) {
-            this.shortcuts.splice(index, 1);
-            if (child.shortcut) {
-                this.container.removeShortcut(child.shortcut);
-            }
-        }
-    }
-    addShortcutToController(node) {
-        node.createShortcut();
-        if (node.shortcut) {
-            this.container.addShortcut(node.shortcut);
+        const shortcut = child.getShortcut();
+        if (shortcut) {
+            this.container.removeShortcut(shortcut);
         }
+        super.removeChild(child);
     }
 }
-registerNodeClass(ShortcutControllerNode);

package/dist/nodes/shortcut.d.ts

@@ -1,39 +1,17 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { Props } from "../types.js";
+import type { ShortcutProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { EventControllerNode } from "./event-controller.js";
 import { VirtualNode } from "./virtual.js";
-/**
- * Props for the Shortcut virtual element.
- *
- * Defines a keyboard shortcut. Must be a child of `x.ShortcutController`.
- *
- * @example
- * ```tsx
- * <x.ShortcutController>
- *     <x.Shortcut trigger="<Control>s" onActivate={save} />
- *     <x.Shortcut trigger={["F5", "<Control>r"]} onActivate={refresh} />
- *     <x.Shortcut trigger="Escape" onActivate={cancel} disabled={!canCancel} />
- * </x.ShortcutController>
- * ```
- */
-export type ShortcutProps = Props & {
-    /** The trigger string(s) using GTK accelerator format (e.g., "\<Control\>s", "F1") */
-    trigger: string | string[];
-    /**
-     * Called when the shortcut is activated.
-     * Return false to indicate the shortcut was not handled; otherwise it is considered handled.
-     */
-    onActivate: () => boolean | void;
-    /** Whether the shortcut is disabled */
-    disabled?: boolean;
-};
-export declare class ShortcutNode extends VirtualNode<ShortcutProps> {
-    static priority: number;
-    static matches(type: string): boolean;
-    shortcut: Gtk.Shortcut | null;
+export declare class ShortcutNode extends VirtualNode<ShortcutProps, EventControllerNode<Gtk.ShortcutController>, never> {
+    isValidChild(_child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    private shortcut;
     private action;
+    commitUpdate(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
+    detachDeletedInstance(): void;
+    getShortcut(): Gtk.Shortcut | null;
     createShortcut(): void;
-    updateProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
-    protected applyOwnProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
-    unmount(): void;
+    private applyOwnProps;
     private createTrigger;
 }

package/dist/nodes/shortcut.js

@@ -1,14 +1,28 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { hasChanged } from "./internal/utils.js";
+import { EventControllerNode } from "./event-controller.js";
+import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 export class ShortcutNode extends VirtualNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "Shortcut";
+    isValidChild(_child) {
+        return false;
+    }
+    isValidParent(parent) {
+        return parent instanceof EventControllerNode && parent.container instanceof Gtk.ShortcutController;
     }
     shortcut = null;
     action = null;
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+    detachDeletedInstance() {
+        this.shortcut = null;
+        this.action = null;
+        super.detachDeletedInstance();
+    }
+    getShortcut() {
+        return this.shortcut;
+    }
     createShortcut() {
         const trigger = this.createTrigger();
         this.action = new Gtk.CallbackAction(() => {
@@ -17,10 +31,6 @@ export class ShortcutNode extends VirtualNode {
         });
         this.shortcut = new Gtk.Shortcut(trigger, this.action);
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
-    }
     applyOwnProps(oldProps, newProps) {
         if (!this.shortcut)
             return;
@@ -28,11 +38,6 @@ export class ShortcutNode extends VirtualNode {
             this.shortcut.setTrigger(this.createTrigger());
         }
     }
-    unmount() {
-        this.shortcut = null;
-        this.action = null;
-        super.unmount();
-    }
     createTrigger() {
         if (this.props.disabled) {
             return Gtk.NeverTrigger.get();
@@ -49,4 +54,3 @@ export class ShortcutNode extends VirtualNode {
         return result;
     }
 }
-registerNodeClass(ShortcutNode);

package/dist/nodes/slot.d.ts

@@ -1,19 +1,20 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
 import type { SlotProps } from "../jsx.js";
+import type { Node } from "../node.js";
 import type { Props } from "../types.js";
-import { VirtualSingleChildNode } from "./abstract/virtual-single-child.js";
-type SlotNodeProps = Omit<SlotProps, "children">;
-export declare class SlotNode<P extends Props = SlotNodeProps> extends VirtualSingleChildNode<P> {
-    static priority: number;
-    static matches(type: string): boolean;
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class SlotNode<P extends Props = SlotProps, TChild extends Node = WidgetNode> extends VirtualNode<P, WidgetNode, TChild> {
     private cachedSetter;
-    setParent(parent: Gtk.Widget | null): void;
-    unmount(): void;
-    getChild(): Gtk.Widget;
-    protected getId(): string;
-    protected getParent(): Gtk.Widget;
-    protected ensureChildSetter(): (child: Gtk.Widget | null) => void;
-    protected onChildChange(oldChild: Gtk.Widget | null): void;
-    private isDescendantOf;
+    private detachedParentWidget;
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode | null): void;
+    appendChild(child: TChild): void;
+    removeChild(child: TChild): void;
+    detachDeletedInstance(): void;
+    private getId;
+    private getParentWidget;
+    private ensureChildSetter;
+    private onChildChange;
+    private resolveChildSetter;
 }
-export {};

package/dist/nodes/slot.js

@@ -1,43 +1,62 @@
-import { isObjectEqual } from "@gtkx/ffi";
 import { toCamelCase } from "@gtkx/gir";
-import { registerNodeClass } from "../registry.js";
-import { VirtualSingleChildNode } from "./abstract/virtual-single-child.js";
-import { resolvePropMeta } from "./internal/utils.js";
-export class SlotNode extends VirtualSingleChildNode {
-    static priority = 2;
-    static matches(type) {
-        return type === "Slot";
-    }
+import { getFocusWidget, isDescendantOf, resolvePropertySetter } from "./internal/widget.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class SlotNode extends VirtualNode {
     cachedSetter = null;
+    detachedParentWidget = null;
+    isValidChild(child) {
+        return child instanceof WidgetNode;
+    }
+    isValidParent(parent) {
+        return parent instanceof WidgetNode;
+    }
     setParent(parent) {
-        if (!isObjectEqual(this.parent, parent)) {
+        const previousParent = this.parent;
+        if (previousParent !== parent) {
             this.cachedSetter = null;
         }
+        if (!parent && previousParent) {
+            this.detachedParentWidget = previousParent.container;
+        }
         super.setParent(parent);
+        if (parent && this.children[0]) {
+            this.onChildChange(null);
+        }
     }
-    unmount() {
-        if (this.parent && this.child) {
-            const parent = this.parent;
-            const oldChild = this.child;
-            this.child = null;
-            queueMicrotask(() => {
-                if (parent.getRoot() !== null) {
-                    this.parent = parent;
-                    this.onChildChange(oldChild);
-                }
-                this.parent = null;
-            });
+    appendChild(child) {
+        const firstChild = this.children[0];
+        const oldChildWidget = firstChild instanceof WidgetNode ? firstChild.container : null;
+        super.appendChild(child);
+        if (this.parent) {
+            this.onChildChange(oldChildWidget);
         }
-        else {
-            this.parent = null;
+    }
+    removeChild(child) {
+        const oldChildWidget = child instanceof WidgetNode ? child.container : null;
+        super.removeChild(child);
+        if (this.parent && oldChildWidget) {
+            this.onChildChange(oldChildWidget);
         }
-        super.unmount();
     }
-    getChild() {
-        if (!this.child) {
-            throw new Error(`Expected child widget to be set on '${this.getId()}' SlotNode`);
+    detachDeletedInstance() {
+        const parentWidget = this.detachedParentWidget;
+        if (parentWidget && this.children[0]) {
+            if (parentWidget.getRoot() !== null) {
+                this.cachedSetter = null;
+                const setter = this.resolveChildSetter(parentWidget);
+                if (setter) {
+                    const oldChild = this.children[0].container;
+                    const focus = getFocusWidget(oldChild);
+                    if (focus && isDescendantOf(focus, oldChild)) {
+                        parentWidget.grabFocus();
+                    }
+                    setter(null);
+                }
+            }
+            this.detachedParentWidget = null;
         }
-        return this.child;
+        super.detachDeletedInstance();
     }
     getId() {
         const id = this.props.id;
@@ -46,50 +65,37 @@ export class SlotNode extends VirtualSingleChildNode {
         }
         return toCamelCase(id);
     }
-    getParent() {
+    getParentWidget() {
         if (!this.parent) {
             throw new Error(`Expected parent widget to be set on '${this.getId()}' SlotNode`);
         }
-        return this.parent;
+        return this.parent.container;
     }
     ensureChildSetter() {
         if (this.cachedSetter)
             return this.cachedSetter;
-        const parent = this.getParent();
-        const parentType = parent.constructor.glibTypeName;
-        const propMeta = resolvePropMeta(parent, this.getId());
-        if (!propMeta) {
+        const parent = this.getParentWidget();
+        const setter = this.resolveChildSetter(parent);
+        if (!setter) {
+            const parentType = parent.constructor.glibTypeName;
             throw new Error(`Unable to find property for Slot '${this.getId()}' on type '${parentType}'`);
         }
-        const [, setterName] = propMeta;
-        const setter = parent[setterName];
-        if (typeof setter !== "function") {
-            throw new Error(`Expected setter function for Slot '${this.getId()}' on type '${parentType}'`);
-        }
-        this.cachedSetter = setter.bind(parent);
+        this.cachedSetter = setter;
         return this.cachedSetter;
     }
     onChildChange(oldChild) {
         const setter = this.ensureChildSetter();
-        if (oldChild && !this.child) {
-            const parent = this.getParent();
-            const root = oldChild.getRoot();
-            const focusWidget = root?.getFocus?.();
-            if (focusWidget && this.isDescendantOf(focusWidget, oldChild)) {
+        const childWidget = this.children[0]?.container ?? null;
+        if (oldChild && !childWidget) {
+            const parent = this.getParentWidget();
+            const focus = getFocusWidget(oldChild);
+            if (focus && isDescendantOf(focus, oldChild)) {
                 parent.grabFocus();
             }
         }
-        setter(this.child);
+        setter(childWidget);
     }
-    isDescendantOf(widget, ancestor) {
-        let current = widget;
-        while (current) {
-            if (isObjectEqual(current, ancestor)) {
-                return true;
-            }
-            current = current.getParent();
-        }
-        return false;
+    resolveChildSetter(parent) {
+        return resolvePropertySetter(parent, this.getId());
     }
 }
-registerNodeClass(SlotNode);

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

@@ -1 +1,17 @@
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import type { GtkSourceViewProps } from "../jsx.js";
+import { TextBufferController } from "./internal/text-buffer-controller.js";
+import { TextViewNode } from "./text-view.js";
+declare const OWN_PROPS: readonly ["language", "styleScheme", "highlightSyntax", "highlightMatchingBrackets", "implicitTrailingNewline", "onCursorMoved", "onHighlightUpdated"];
+type SourceViewProps = Pick<GtkSourceViewProps, "enableUndo" | "onBufferChanged" | "onTextInserted" | "onTextDeleted" | "onCanUndoChanged" | "onCanRedoChanged" | (typeof OWN_PROPS)[number]>;
+export declare class SourceViewNode extends TextViewNode {
+    protected createBufferController(): TextBufferController<GtkSource.Buffer>;
+    protected ensureBufferController(): TextBufferController<GtkSource.Buffer>;
+    commitUpdate(oldProps: SourceViewProps | null, newProps: SourceViewProps): void;
+    private resolveLanguage;
+    private resolveStyleScheme;
+    private applyOwnProps;
+    private applyBufferProps;
+    private applySignalProps;
+}
 export {};

package/dist/nodes/source-view.js

@@ -1,22 +1,26 @@
 import * as GtkSource from "@gtkx/ffi/gtksource";
-import { registerNodeClass } from "../registry.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { TextBufferController } from "./internal/text-buffer-controller.js";
-import { hasChanged, matchesAnyClass } from "./internal/utils.js";
 import { TextViewNode } from "./text-view.js";
-class SourceViewNode extends TextViewNode {
-    static priority = 1;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([GtkSource.View], containerOrClass);
-    }
+const OWN_PROPS = [
+    "language",
+    "styleScheme",
+    "highlightSyntax",
+    "highlightMatchingBrackets",
+    "implicitTrailingNewline",
+    "onCursorMoved",
+    "onHighlightUpdated",
+];
+export class SourceViewNode extends TextViewNode {
     createBufferController() {
         return new TextBufferController(this, this.container, () => new GtkSource.Buffer());
     }
     ensureBufferController() {
         return super.ensureBufferController();
     }
-    applyOwnProps(oldProps, newProps) {
-        super.applyOwnProps(oldProps, newProps);
-        this.applySourceViewProps(oldProps, newProps);
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
     }
     resolveLanguage(language) {
         if (typeof language === "string") {
@@ -32,62 +36,58 @@ class SourceViewNode extends TextViewNode {
         }
         return scheme;
     }
-    applySourceViewProps(oldProps, newProps) {
-        const hasSourceViewProps = newProps.language !== undefined ||
-            newProps.styleScheme !== undefined ||
-            newProps.highlightSyntax !== undefined ||
-            newProps.highlightMatchingBrackets !== undefined ||
-            newProps.implicitTrailingNewline !== undefined ||
-            newProps.onCursorMoved !== undefined ||
-            newProps.onHighlightUpdated !== undefined ||
-            oldProps?.language !== undefined ||
-            oldProps?.styleScheme !== undefined;
-        if (!hasSourceViewProps) {
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "onCursorMoved") || hasChanged(oldProps, newProps, "onHighlightUpdated")) {
+            this.applySignalProps(newProps);
+        }
+        this.applyBufferProps(oldProps, newProps);
+    }
+    applyBufferProps(oldProps, newProps) {
+        const languageChanged = hasChanged(oldProps, newProps, "language");
+        const styleSchemeChanged = hasChanged(oldProps, newProps, "styleScheme");
+        const highlightSyntaxChanged = hasChanged(oldProps, newProps, "highlightSyntax");
+        const highlightBracketsChanged = hasChanged(oldProps, newProps, "highlightMatchingBrackets");
+        const trailingNewlineChanged = hasChanged(oldProps, newProps, "implicitTrailingNewline");
+        if (!languageChanged &&
+            !styleSchemeChanged &&
+            !highlightSyntaxChanged &&
+            !highlightBracketsChanged &&
+            !trailingNewlineChanged) {
             return;
         }
         const buffer = this.ensureBufferController().ensureBuffer();
-        if (hasChanged(oldProps, newProps, "language")) {
+        if (languageChanged) {
             if (newProps.language !== undefined) {
-                const language = this.resolveLanguage(newProps.language);
-                buffer.setLanguage(language);
+                buffer.setLanguage(this.resolveLanguage(newProps.language));
             }
             else if (oldProps?.language !== undefined) {
                 buffer.setLanguage(null);
             }
         }
-        if (hasChanged(oldProps, newProps, "styleScheme")) {
+        if (styleSchemeChanged) {
             if (newProps.styleScheme !== undefined) {
-                const scheme = this.resolveStyleScheme(newProps.styleScheme);
-                buffer.setStyleScheme(scheme);
+                buffer.setStyleScheme(this.resolveStyleScheme(newProps.styleScheme));
             }
             else if (oldProps?.styleScheme !== undefined) {
                 buffer.setStyleScheme(null);
             }
         }
-        if (hasChanged(oldProps, newProps, "highlightSyntax") || hasChanged(oldProps, newProps, "language")) {
-            const highlightSyntax = newProps.highlightSyntax ?? newProps.language !== undefined;
-            buffer.setHighlightSyntax(highlightSyntax);
-        }
-        if (hasChanged(oldProps, newProps, "highlightMatchingBrackets")) {
-            const highlightMatchingBrackets = newProps.highlightMatchingBrackets ?? true;
-            buffer.setHighlightMatchingBrackets(highlightMatchingBrackets);
+        if (highlightSyntaxChanged || languageChanged) {
+            buffer.setHighlightSyntax(newProps.highlightSyntax ?? newProps.language !== undefined);
         }
-        if (hasChanged(oldProps, newProps, "implicitTrailingNewline")) {
-            if (newProps.implicitTrailingNewline !== undefined) {
-                buffer.setImplicitTrailingNewline(newProps.implicitTrailingNewline);
-            }
+        if (highlightBracketsChanged) {
+            buffer.setHighlightMatchingBrackets(newProps.highlightMatchingBrackets ?? true);
         }
-        if (hasChanged(oldProps, newProps, "onCursorMoved") || hasChanged(oldProps, newProps, "onHighlightUpdated")) {
-            this.updateSourceViewSignalHandlers(newProps);
+        if (trailingNewlineChanged && newProps.implicitTrailingNewline !== undefined) {
+            buffer.setImplicitTrailingNewline(newProps.implicitTrailingNewline);
         }
     }
-    updateSourceViewSignalHandlers(props) {
+    applySignalProps(props) {
         const buffer = this.ensureBufferController().getBuffer();
         if (!buffer)
             return;
         const { onCursorMoved, onHighlightUpdated } = props;
-        this.signalStore.set(this, buffer, "cursor-moved", onCursorMoved ?? null);
-        this.signalStore.set(this, buffer, "highlight-updated", onHighlightUpdated ? (start, end) => onHighlightUpdated(start, end) : null);
+        this.signalStore.set(this, buffer, "cursor-moved", onCursorMoved);
+        this.signalStore.set(this, buffer, "highlight-updated", onHighlightUpdated ? (start, end) => onHighlightUpdated(start, end) : undefined);
     }
 }
-registerNodeClass(SourceViewNode);