@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/internal/signal-store.js

@@ -1,4 +1,3 @@
-import { getNativeId } from "@gtkx/ffi";
 import * as GObject from "@gtkx/ffi/gobject";
 const LIFECYCLE_SIGNALS = new Set([
     "realize",
@@ -15,6 +14,16 @@ const LIFECYCLE_SIGNALS = new Set([
     "unbind",
     "teardown",
 ]);
+const signalKeyCache = new WeakMap();
+let nextSignalObjId = 0;
+function getSignalKey(obj, signal) {
+    let objKey = signalKeyCache.get(obj);
+    if (!objKey) {
+        objKey = String(nextSignalObjId++);
+        signalKeyCache.set(obj, objKey);
+    }
+    return `${objKey}:${signal}`;
+}
 export class SignalStore {
     ownerHandlers = new Map();
     blockDepth = 0;
@@ -36,8 +45,7 @@ export class SignalStore {
         };
     }
     disconnect(owner, obj, signal) {
-        const objectId = getNativeId(obj.handle);
-        const key = `${objectId}:${signal}`;
+        const key = getSignalKey(obj, signal);
         const ownerMap = this.ownerHandlers.get(owner);
         const existing = ownerMap?.get(key);
         if (existing) {
@@ -46,8 +54,7 @@ export class SignalStore {
         }
     }
     connect(owner, obj, signal, handler, blockable) {
-        const objectId = getNativeId(obj.handle);
-        const key = `${objectId}:${signal}`;
+        const key = getSignalKey(obj, signal);
         const wrappedHandler = this.wrapHandler(handler, signal, blockable);
         const handlerId = obj.connect(signal, wrappedHandler);
         this.getOwnerMap(owner).set(key, { obj, handlerId });

package/dist/nodes/internal/simple-list-store.d.ts

@@ -1,7 +1,11 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 export declare class SimpleListStore {
     private ids;
+    private idToIndex;
     private model;
+    private pendingBatch;
+    beginBatch(): void;
+    flushBatch(): void;
     addItem(id: string, label: string): void;
     appendItem(id: string, label: string): void;
     removeItem(id: string): void;
@@ -11,4 +15,5 @@ export declare class SimpleListStore {
     getIdAtIndex(index: number): string | null;
     getIndexById(id: string): number | null;
     getModel(): Gtk.StringList;
+    private rebuildIndices;
 }

package/dist/nodes/internal/simple-list-store.js

@@ -1,57 +1,86 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 export class SimpleListStore {
     ids = [];
+    idToIndex = new Map();
     model = new Gtk.StringList();
+    pendingBatch = null;
+    beginBatch() {
+        this.pendingBatch = [];
+    }
+    flushBatch() {
+        const batch = this.pendingBatch;
+        this.pendingBatch = null;
+        if (batch && batch.length > 0) {
+            this.model.splice(0, 0, batch);
+        }
+    }
     addItem(id, label) {
+        this.idToIndex.set(id, this.ids.length);
         this.ids.push(id);
-        this.model.append(label);
+        if (this.pendingBatch) {
+            this.pendingBatch.push(label);
+        }
+        else {
+            this.model.append(label);
+        }
     }
     appendItem(id, label) {
-        const existingIndex = this.ids.indexOf(id);
-        if (existingIndex >= 0) {
+        const existingIndex = this.idToIndex.get(id);
+        if (existingIndex !== undefined) {
             this.model.remove(existingIndex);
             this.ids.splice(existingIndex, 1);
+            this.rebuildIndices(existingIndex);
         }
+        this.idToIndex.set(id, this.ids.length);
         this.ids.push(id);
         this.model.append(label);
     }
     removeItem(id) {
-        const index = this.ids.indexOf(id);
-        if (index < 0) {
+        const index = this.idToIndex.get(id);
+        if (index === undefined)
             return;
-        }
         this.model.remove(index);
         this.ids.splice(index, 1);
+        this.idToIndex.delete(id);
+        this.rebuildIndices(index);
     }
     insertItemBefore(id, beforeId, label) {
-        const beforeIndex = this.ids.indexOf(beforeId);
-        if (beforeIndex < 0) {
+        const beforeIndex = this.idToIndex.get(beforeId);
+        if (beforeIndex === undefined) {
             this.addItem(id, label);
         }
         else {
             this.ids.splice(beforeIndex, 0, id);
+            this.rebuildIndices(beforeIndex);
             this.model.splice(beforeIndex, 0, [label]);
         }
     }
     updateItem(id, label) {
-        const index = this.ids.indexOf(id);
-        if (index < 0) {
+        const index = this.idToIndex.get(id);
+        if (index === undefined) {
             this.addItem(id, label);
             return;
         }
         this.model.splice(index, 1, [label]);
     }
     getItem(id) {
-        return this.model.getString(this.ids.indexOf(id));
+        const index = this.idToIndex.get(id);
+        if (index === undefined)
+            return null;
+        return this.model.getString(index);
     }
     getIdAtIndex(index) {
         return this.ids[index] ?? null;
     }
     getIndexById(id) {
-        const index = this.ids.indexOf(id);
-        return index >= 0 ? index : null;
+        return this.idToIndex.get(id) ?? null;
     }
     getModel() {
         return this.model;
     }
+    rebuildIndices(fromIndex) {
+        for (let i = fromIndex; i < this.ids.length; i++) {
+            this.idToIndex.set(this.ids[i], i);
+        }
+    }
 }

package/dist/nodes/internal/text-buffer-controller.d.ts

@@ -1,17 +1,10 @@
 import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkTextViewProps } from "../../jsx.js";
 import type { Node } from "../../node.js";
 import type { TextContentChild, TextContentParent } from "../text-content.js";
 import { TextSegmentNode } from "../text-segment.js";
-type BufferCallbackProps = {
-    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;
-};
-type BufferProps = {
-    enableUndo?: boolean;
-} & BufferCallbackProps;
+type BufferCallbackProps = Pick<GtkTextViewProps, "onBufferChanged" | "onTextInserted" | "onTextDeleted" | "onCanUndoChanged" | "onCanRedoChanged">;
+type BufferProps = Pick<GtkTextViewProps, "enableUndo"> & BufferCallbackProps;
 export declare class TextBufferController<TBuffer extends Gtk.TextBuffer = Gtk.TextBuffer> {
     private readonly owner;
     private readonly container;
@@ -23,12 +16,11 @@ export declare class TextBufferController<TBuffer extends Gtk.TextBuffer = Gtk.T
     hasTextChildren(): boolean;
     ensureBuffer(): TBuffer;
     applyOwnProps(oldProps: BufferProps | null, newProps: BufferProps): void;
-    private updateSignalHandlers;
+    private setSignalHandlersChanged;
     isTextContentChild(child: Node): child is TextContentChild;
     appendChild(child: TextContentChild): void;
     insertBefore(child: TextContentChild, before: TextContentChild): void;
     removeChild(child: TextContentChild): void;
-    private setChildParent;
     private getTotalLength;
     private insertTextAtOffset;
     private deleteTextAtRange;

package/dist/nodes/internal/text-buffer-controller.js

@@ -3,7 +3,7 @@ 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 { hasChanged } from "./utils.js";
+import { hasChanged } from "./props.js";
 export class TextBufferController {
     owner;
     container;
@@ -48,10 +48,10 @@ export class TextBufferController {
             hasChanged(oldProps, newProps, "onCanUndoChanged") ||
             hasChanged(oldProps, newProps, "onCanRedoChanged");
         if (signalHandlersChanged) {
-            this.updateSignalHandlers(newProps);
+            this.setSignalHandlersChanged(newProps);
         }
     }
-    updateSignalHandlers(callbacks) {
+    setSignalHandlersChanged(callbacks) {
         if (!this.buffer)
             return;
         const buffer = this.buffer;
@@ -77,7 +77,7 @@ export class TextBufferController {
         const wasMoved = this.textChildren.indexOf(child) !== -1;
         if (wasMoved) {
             const existingIndex = this.textChildren.indexOf(child);
-            const oldOffset = child.bufferOffset;
+            const oldOffset = child.getBufferOffset();
             const oldLength = child.getLength();
             this.textChildren.splice(existingIndex, 1);
             if (oldLength > 0) {
@@ -87,8 +87,7 @@ export class TextBufferController {
         }
         const offset = this.getTotalLength();
         this.textChildren.push(child);
-        child.bufferOffset = offset;
-        this.setChildParent(child);
+        child.setBufferOffset(offset);
         if (child instanceof TextSegmentNode) {
             this.insertTextAtOffset(child.getText(), offset);
         }
@@ -114,7 +113,7 @@ export class TextBufferController {
         const buffer = this.ensureBuffer();
         const existingIndex = this.textChildren.indexOf(child);
         if (existingIndex !== -1) {
-            const oldOffset = child.bufferOffset;
+            const oldOffset = child.getBufferOffset();
             const oldLength = child.getLength();
             this.textChildren.splice(existingIndex, 1);
             if (oldLength > 0) {
@@ -131,8 +130,7 @@ export class TextBufferController {
                 offset += c.getLength();
         }
         this.textChildren.splice(insertIndex, 0, child);
-        child.bufferOffset = offset;
-        this.setChildParent(child);
+        child.setBufferOffset(offset);
         if (child instanceof TextSegmentNode) {
             this.insertTextAtOffset(child.getText(), offset);
         }
@@ -156,7 +154,7 @@ export class TextBufferController {
         const index = this.textChildren.indexOf(child);
         if (index === -1)
             return;
-        const offset = child.bufferOffset;
+        const offset = child.getBufferOffset();
         const length = child.getLength();
         this.textChildren.splice(index, 1);
         if (this.buffer && length > 0) {
@@ -165,11 +163,6 @@ export class TextBufferController {
         this.updateChildOffsets(index);
         this.reapplyTagsFromOffset(offset);
     }
-    setChildParent(child) {
-        if (child instanceof TextSegmentNode || child instanceof TextTagNode) {
-            child.setParent(this.owner);
-        }
-    }
     getTotalLength() {
         let length = 0;
         for (const child of this.textChildren) {
@@ -205,7 +198,7 @@ export class TextBufferController {
         for (let i = startIndex; i < this.textChildren.length; i++) {
             const child = this.textChildren[i];
             if (child) {
-                child.bufferOffset = offset;
+                child.setBufferOffset(offset);
                 offset += child.getLength();
             }
         }
@@ -214,20 +207,20 @@ export class TextBufferController {
         for (const child of children) {
             if (child instanceof TextTagNode) {
                 child.reapplyTag();
-                this.reapplyAllTagsRecursive(child.getChildren());
+                this.reapplyAllTagsRecursive(child.children);
             }
         }
     }
     reapplyTagsFromOffset(fromOffset) {
         for (const child of this.textChildren) {
             if (child instanceof TextTagNode) {
-                if (child.bufferOffset >= fromOffset) {
+                if (child.getBufferOffset() >= fromOffset) {
                     child.reapplyTag();
-                    this.reapplyAllTagsRecursive(child.getChildren());
+                    this.reapplyAllTagsRecursive(child.children);
                 }
-                else if (child.bufferOffset + child.getLength() > fromOffset) {
+                else if (child.getBufferOffset() + child.getLength() > fromOffset) {
                     child.reapplyTag();
-                    this.reapplyAllTagsRecursive(child.getChildren());
+                    this.reapplyAllTagsRecursive(child.children);
                 }
             }
         }
@@ -236,7 +229,7 @@ export class TextBufferController {
         for (let i = 0; i < this.textChildren.length; i++) {
             const child = this.textChildren[i];
             if (child) {
-                const start = child.bufferOffset;
+                const start = child.getBufferOffset();
                 const end = start + child.getLength();
                 if (offset >= start && offset <= end) {
                     return i;
@@ -250,18 +243,18 @@ export class TextBufferController {
             return;
         const text = child.getText();
         if (text.length > 0) {
-            this.insertTextAtOffset(text, child.bufferOffset);
+            this.insertTextAtOffset(text, child.getBufferOffset());
         }
-        const containingIndex = this.findDirectChildContaining(child.bufferOffset);
+        const containingIndex = this.findDirectChildContaining(child.getBufferOffset());
         if (containingIndex !== -1) {
             this.updateChildOffsets(containingIndex + 1);
         }
-        this.reapplyTagsFromOffset(child.bufferOffset);
+        this.reapplyTagsFromOffset(child.getBufferOffset());
     }
     onChildRemoved(child) {
         if (!this.buffer)
             return;
-        const offset = child.bufferOffset;
+        const offset = child.getBufferOffset();
         const length = child.getLength();
         if (length > 0) {
             this.deleteTextAtRange(offset, offset + length);
@@ -275,13 +268,19 @@ export class TextBufferController {
     onChildTextChanged(child, oldLength, _newLength) {
         if (!this.buffer)
             return;
-        const offset = child.bufferOffset;
-        this.deleteTextAtRange(offset, offset + oldLength);
-        this.insertTextAtOffset(child.getText(), offset);
-        const containingIndex = this.findDirectChildContaining(offset);
-        if (containingIndex !== -1) {
-            this.updateChildOffsets(containingIndex + 1);
+        this.owner.signalStore.blockAll();
+        try {
+            const offset = child.getBufferOffset();
+            this.deleteTextAtRange(offset, offset + oldLength);
+            this.insertTextAtOffset(child.getText(), offset);
+            const containingIndex = this.findDirectChildContaining(offset);
+            if (containingIndex !== -1) {
+                this.updateChildOffsets(containingIndex + 1);
+            }
+            this.reapplyTagsFromOffset(offset);
+        }
+        finally {
+            this.owner.signalStore.unblockAll();
         }
-        this.reapplyTagsFromOffset(offset);
     }
 }

package/dist/nodes/internal/tree-store.d.ts

@@ -8,12 +8,17 @@ export type TreeItemData<T = unknown> = {
 };
 export declare class TreeStore {
     private rootIds;
+    private rootIdToIndex;
     private children;
+    private childIdToIndex;
     private rootModel;
     private childModels;
     private items;
     private onItemUpdated;
+    private pendingBatch;
     setOnItemUpdated(callback: TreeItemUpdatedCallback | null): void;
+    beginBatch(): void;
+    flushBatch(): void;
     updateItem(id: string, item: TreeItemData): void;
     addItem(id: string, data: TreeItemData, parentId?: string): void;
     removeItem(id: string, parentId?: string): void;
@@ -22,4 +27,6 @@ export declare class TreeStore {
     getRootModel(): Gtk.StringList;
     getChildrenModel(parentId: string): Gtk.StringList | null;
     hasChildren(parentId: string): boolean;
+    private rebuildRootIndices;
+    private rebuildChildIndices;
 }

package/dist/nodes/internal/tree-store.js

@@ -1,14 +1,27 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 export class TreeStore {
     rootIds = [];
+    rootIdToIndex = new Map();
     children = new Map();
+    childIdToIndex = new Map();
     rootModel = new Gtk.StringList();
     childModels = new Map();
     items = new Map();
     onItemUpdated = null;
+    pendingBatch = null;
     setOnItemUpdated(callback) {
         this.onItemUpdated = callback;
     }
+    beginBatch() {
+        this.pendingBatch = [];
+    }
+    flushBatch() {
+        const batch = this.pendingBatch;
+        this.pendingBatch = null;
+        if (batch && batch.length > 0) {
+            this.rootModel.splice(0, 0, batch);
+        }
+    }
     updateItem(id, item) {
         if (this.items.has(id)) {
             this.items.set(id, item);
@@ -21,28 +34,42 @@ export class TreeStore {
     addItem(id, data, parentId) {
         this.items.set(id, data);
         if (parentId === undefined) {
-            const existingIndex = this.rootIds.indexOf(id);
-            if (existingIndex >= 0) {
+            const existingIndex = this.rootIdToIndex.get(id);
+            if (existingIndex !== undefined) {
                 this.rootModel.remove(existingIndex);
                 this.rootIds.splice(existingIndex, 1);
+                this.rebuildRootIndices(existingIndex);
             }
+            this.rootIdToIndex.set(id, this.rootIds.length);
             this.rootIds.push(id);
-            this.rootModel.append(id);
+            if (this.pendingBatch) {
+                this.pendingBatch.push(id);
+            }
+            else {
+                this.rootModel.append(id);
+            }
         }
         else {
             let siblings = this.children.get(parentId);
+            let indexMap = this.childIdToIndex.get(parentId);
             if (!siblings) {
                 siblings = [];
                 this.children.set(parentId, siblings);
             }
-            const existingIndex = siblings.indexOf(id);
-            if (existingIndex >= 0) {
+            if (!indexMap) {
+                indexMap = new Map();
+                this.childIdToIndex.set(parentId, indexMap);
+            }
+            const existingIndex = indexMap.get(id);
+            if (existingIndex !== undefined) {
                 const model = this.childModels.get(parentId);
                 if (model) {
                     model.remove(existingIndex);
                 }
                 siblings.splice(existingIndex, 1);
+                this.rebuildChildIndices(siblings, indexMap, existingIndex);
             }
+            indexMap.set(id, siblings.length);
             siblings.push(id);
             let model = this.childModels.get(parentId);
             if (!model) {
@@ -55,20 +82,26 @@ export class TreeStore {
     removeItem(id, parentId) {
         this.items.delete(id);
         this.children.delete(id);
+        this.childIdToIndex.delete(id);
         this.childModels.delete(id);
         if (parentId === undefined) {
-            const index = this.rootIds.indexOf(id);
-            if (index >= 0) {
+            const index = this.rootIdToIndex.get(id);
+            if (index !== undefined) {
                 this.rootIds.splice(index, 1);
+                this.rootIdToIndex.delete(id);
+                this.rebuildRootIndices(index);
                 this.rootModel.remove(index);
             }
         }
         else {
             const siblings = this.children.get(parentId);
-            if (siblings) {
-                const index = siblings.indexOf(id);
-                if (index >= 0) {
+            const indexMap = this.childIdToIndex.get(parentId);
+            if (siblings && indexMap) {
+                const index = indexMap.get(id);
+                if (index !== undefined) {
                     siblings.splice(index, 1);
+                    indexMap.delete(id);
+                    this.rebuildChildIndices(siblings, indexMap, index);
                     const model = this.childModels.get(parentId);
                     if (model) {
                         model.remove(index);
@@ -76,6 +109,7 @@ export class TreeStore {
                 }
                 if (siblings.length === 0) {
                     this.children.delete(parentId);
+                    this.childIdToIndex.delete(parentId);
                 }
             }
         }
@@ -83,44 +117,57 @@ export class TreeStore {
     insertItemBefore(id, beforeId, data, parentId) {
         this.items.set(id, data);
         if (parentId === undefined) {
-            const existingIndex = this.rootIds.indexOf(id);
-            if (existingIndex >= 0) {
+            const existingIndex = this.rootIdToIndex.get(id);
+            if (existingIndex !== undefined) {
                 this.rootModel.remove(existingIndex);
                 this.rootIds.splice(existingIndex, 1);
+                this.rootIdToIndex.delete(id);
+                this.rebuildRootIndices(existingIndex);
             }
-            const beforeIndex = this.rootIds.indexOf(beforeId);
-            if (beforeIndex < 0) {
+            const beforeIndex = this.rootIdToIndex.get(beforeId);
+            if (beforeIndex === undefined) {
+                this.rootIdToIndex.set(id, this.rootIds.length);
                 this.rootIds.push(id);
                 this.rootModel.append(id);
             }
             else {
                 this.rootIds.splice(beforeIndex, 0, id);
+                this.rebuildRootIndices(beforeIndex);
                 this.rootModel.splice(beforeIndex, 0, [id]);
             }
         }
         else {
             let siblings = this.children.get(parentId);
+            let indexMap = this.childIdToIndex.get(parentId);
             if (!siblings) {
                 siblings = [];
                 this.children.set(parentId, siblings);
             }
+            if (!indexMap) {
+                indexMap = new Map();
+                this.childIdToIndex.set(parentId, indexMap);
+            }
             let model = this.childModels.get(parentId);
             if (!model) {
                 model = new Gtk.StringList();
                 this.childModels.set(parentId, model);
             }
-            const existingIndex = siblings.indexOf(id);
-            if (existingIndex >= 0) {
+            const existingIndex = indexMap.get(id);
+            if (existingIndex !== undefined) {
                 model.remove(existingIndex);
                 siblings.splice(existingIndex, 1);
+                indexMap.delete(id);
+                this.rebuildChildIndices(siblings, indexMap, existingIndex);
             }
-            const beforeIndex = siblings.indexOf(beforeId);
-            if (beforeIndex < 0) {
+            const beforeIndex = indexMap.get(beforeId);
+            if (beforeIndex === undefined) {
+                indexMap.set(id, siblings.length);
                 siblings.push(id);
                 model.append(id);
             }
             else {
                 siblings.splice(beforeIndex, 0, id);
+                this.rebuildChildIndices(siblings, indexMap, beforeIndex);
                 model.splice(beforeIndex, 0, [id]);
             }
         }
@@ -147,4 +194,14 @@ export class TreeStore {
         const childIds = this.children.get(parentId);
         return childIds !== undefined && childIds.length > 0;
     }
+    rebuildRootIndices(fromIndex) {
+        for (let i = fromIndex; i < this.rootIds.length; i++) {
+            this.rootIdToIndex.set(this.rootIds[i], i);
+        }
+    }
+    rebuildChildIndices(siblings, indexMap, fromIndex) {
+        for (let i = fromIndex; i < siblings.length; i++) {
+            indexMap.set(siblings[i], i);
+        }
+    }
 }

package/dist/nodes/internal/widget.d.ts

@@ -0,0 +1,7 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+export declare function detachChild(child: Gtk.Widget, container: Gtk.Widget): void;
+export declare function attachChild(child: Gtk.Widget, container: Gtk.Widget): void;
+export declare function isAttachedTo(child: Gtk.Widget | null, parent: Gtk.Widget | null): boolean;
+export declare function getFocusWidget(widget: Gtk.Widget): Gtk.Widget | null;
+export declare function isDescendantOf(widget: Gtk.Widget, ancestor: Gtk.Widget): boolean;
+export declare function resolvePropertySetter(parentWidget: Gtk.Widget, propId: string): ((child: Gtk.Widget | null) => void) | null;

package/dist/nodes/internal/widget.js

@@ -0,0 +1,68 @@
+import { resolvePropMeta } from "../../metadata.js";
+import { isAddable, isAppendable, isContentWidget, isRemovable, isSingleChild } from "./predicates.js";
+export function detachChild(child, container) {
+    if (isAppendable(container) || isAddable(container)) {
+        if (isRemovable(container)) {
+            container.remove(child);
+        }
+    }
+    else if (isContentWidget(container)) {
+        container.setContent(null);
+    }
+    else if (isSingleChild(container)) {
+        container.setChild(null);
+    }
+    else if (isRemovable(container)) {
+        container.remove(child);
+    }
+}
+export function attachChild(child, container) {
+    if (isAppendable(container)) {
+        container.append(child);
+    }
+    else if (isAddable(container)) {
+        container.add(child);
+    }
+    else if (isContentWidget(container)) {
+        container.setContent(child);
+    }
+    else if (isSingleChild(container)) {
+        container.setChild(child);
+    }
+    else {
+        throw new Error(`Cannot attach child to '${container.constructor.name}': container does not support children`);
+    }
+}
+export function isAttachedTo(child, parent) {
+    if (!child || !parent)
+        return false;
+    const childParent = child.getParent();
+    return childParent !== null && childParent === parent;
+}
+export function getFocusWidget(widget) {
+    const root = widget.getRoot();
+    return root?.getFocus?.() ?? null;
+}
+export function isDescendantOf(widget, ancestor) {
+    let current = widget;
+    while (current) {
+        if (current === ancestor) {
+            return true;
+        }
+        current = current.getParent();
+    }
+    return false;
+}
+export function resolvePropertySetter(parentWidget, propId) {
+    const propMeta = resolvePropMeta(parentWidget, propId);
+    if (!propMeta) {
+        return null;
+    }
+    const [, setterName] = propMeta;
+    const setter = parentWidget[setterName];
+    if (typeof setter !== "function") {
+        const parentType = parentWidget.constructor.glibTypeName;
+        throw new Error(`Expected setter function for property '${propId}' on type '${parentType}'`);
+    }
+    return setter.bind(parentWidget);
+}

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

@@ -1 +1,11 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkLevelBarProps } from "../jsx.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["offsets"];
+type LevelBarProps = Pick<GtkLevelBarProps, (typeof OWN_PROPS)[number]>;
+export declare class LevelBarNode extends WidgetNode<Gtk.LevelBar, LevelBarProps> {
+    private appliedOffsets;
+    commitUpdate(oldProps: LevelBarProps | null, newProps: LevelBarProps): void;
+    private applyOwnProps;
+}
 export {};