@gtkx/react 0.18.0 → 0.18.2

package/src/nodes/internal/signal-store.ts

@@ -0,0 +1,141 @@
+import * as GObject from "@gtkx/ffi/gobject";
+
+type SignalOwner = object;
+
+// biome-ignore lint/suspicious/noExplicitAny: Required for contravariant behavior
+export type SignalHandler = (...args: any[]) => any;
+
+const LIFECYCLE_SIGNALS = new Set([
+    "realize",
+    "unrealize",
+    "map",
+    "unmap",
+    "show",
+    "hide",
+    "destroy",
+    "resize",
+    "render",
+    "setup",
+    "bind",
+    "unbind",
+    "teardown",
+]);
+
+type HandlerEntry = { obj: GObject.Object; handlerId: number };
+
+type SignalKey = `${string}:${string}`;
+
+export interface SignalOptions {
+    blockable?: boolean;
+}
+
+const signalKeyCache = new WeakMap<GObject.Object, string>();
+let nextSignalObjId = 0;
+
+function getSignalKey(obj: GObject.Object, signal: string): SignalKey {
+    let objKey = signalKeyCache.get(obj);
+    if (!objKey) {
+        objKey = String(nextSignalObjId++);
+        signalKeyCache.set(obj, objKey);
+    }
+    return `${objKey}:${signal}`;
+}
+
+export class SignalStore {
+    private ownerHandlers: Map<SignalOwner, Map<SignalKey, HandlerEntry>> = new Map();
+    private blockDepth = 0;
+
+    private getOwnerMap(owner: SignalOwner): Map<SignalKey, HandlerEntry> {
+        let map = this.ownerHandlers.get(owner);
+        if (!map) {
+            map = new Map();
+            this.ownerHandlers.set(owner, map);
+        }
+        return map;
+    }
+
+    private wrapHandler(handler: SignalHandler, signal: string, blockable: boolean): SignalHandler {
+        return (...args: unknown[]) => {
+            if (this.blockDepth > 0 && blockable && !LIFECYCLE_SIGNALS.has(signal)) {
+                return;
+            }
+            const [self, ...rest] = args;
+            return handler(...rest, self);
+        };
+    }
+
+    private disconnect(owner: SignalOwner, obj: GObject.Object, signal: string): void {
+        const key = getSignalKey(obj, signal);
+        const ownerMap = this.ownerHandlers.get(owner);
+        const existing = ownerMap?.get(key);
+
+        if (existing) {
+            GObject.signalHandlerDisconnect(existing.obj, existing.handlerId);
+            ownerMap?.delete(key);
+        }
+    }
+
+    private connect(
+        owner: SignalOwner,
+        obj: GObject.Object,
+        signal: string,
+        handler: SignalHandler,
+        blockable: boolean,
+    ): void {
+        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 });
+    }
+
+    public set(
+        owner: SignalOwner,
+        obj: GObject.Object,
+        signal: string,
+        handler?: SignalHandler | null,
+        options?: SignalOptions,
+    ): void {
+        this.disconnect(owner, obj, signal);
+
+        if (handler) {
+            this.connect(owner, obj, signal, handler, options?.blockable ?? true);
+        }
+    }
+
+    public clear(owner: SignalOwner): void {
+        const ownerMap = this.ownerHandlers.get(owner);
+
+        if (ownerMap) {
+            for (const { obj, handlerId } of ownerMap.values()) {
+                GObject.signalHandlerDisconnect(obj, handlerId);
+            }
+
+            this.ownerHandlers.delete(owner);
+        }
+    }
+
+    public blockAll(): void {
+        this.blockDepth++;
+    }
+
+    public unblockAll(): void {
+        if (this.blockDepth > 0) {
+            this.blockDepth--;
+        }
+    }
+
+    public forceUnblockAll(): void {
+        this.blockDepth = 0;
+    }
+}
+
+const signalStores = new WeakMap<object, SignalStore>();
+
+export function getSignalStore(rootContainer: object): SignalStore {
+    let store = signalStores.get(rootContainer);
+    if (!store) {
+        store = new SignalStore();
+        signalStores.set(rootContainer, store);
+    }
+    return store;
+}

package/src/nodes/internal/simple-list-store.ts

@@ -0,0 +1,99 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+
+export class SimpleListStore {
+    private ids: string[] = [];
+    private idToIndex = new Map<string, number>();
+    private model = new Gtk.StringList();
+    private pendingBatch: string[] | null = null;
+
+    public beginBatch(): void {
+        this.pendingBatch = [];
+    }
+
+    public flushBatch(): void {
+        const batch = this.pendingBatch;
+        this.pendingBatch = null;
+        if (batch && batch.length > 0) {
+            this.model.splice(0, 0, batch);
+        }
+    }
+
+    public addItem(id: string, label: string): void {
+        this.idToIndex.set(id, this.ids.length);
+        this.ids.push(id);
+
+        if (this.pendingBatch) {
+            this.pendingBatch.push(label);
+        } else {
+            this.model.append(label);
+        }
+    }
+
+    public appendItem(id: string, label: string): void {
+        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);
+    }
+
+    public removeItem(id: string): void {
+        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);
+    }
+
+    public insertItemBefore(id: string, beforeId: string, label: string): void {
+        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]);
+        }
+    }
+
+    public updateItem(id: string, label: string): void {
+        const index = this.idToIndex.get(id);
+        if (index === undefined) {
+            this.addItem(id, label);
+            return;
+        }
+        this.model.splice(index, 1, [label]);
+    }
+
+    public getItem(id: string) {
+        const index = this.idToIndex.get(id);
+        if (index === undefined) return null;
+        return this.model.getString(index);
+    }
+
+    public getIdAtIndex(index: number): string | null {
+        return this.ids[index] ?? null;
+    }
+
+    public getIndexById(id: string): number | null {
+        return this.idToIndex.get(id) ?? null;
+    }
+
+    public getModel(): Gtk.StringList {
+        return this.model;
+    }
+
+    private rebuildIndices(fromIndex: number): void {
+        for (let i = fromIndex; i < this.ids.length; i++) {
+            this.idToIndex.set(this.ids[i] as string, i);
+        }
+    }
+}

package/src/nodes/internal/text-buffer-controller.ts

@@ -0,0 +1,374 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkTextViewProps } from "../../jsx.js";
+import type { Node } from "../../node.js";
+import { TextAnchorNode } from "../text-anchor.js";
+import type { TextContentChild, TextContentParent } from "../text-content.js";
+import { TextPaintableNode } from "../text-paintable.js";
+import { TextSegmentNode } from "../text-segment.js";
+import { TextTagNode } from "../text-tag.js";
+import { hasChanged } from "./props.js";
+
+type BufferCallbackProps = Pick<
+    GtkTextViewProps,
+    "onBufferChanged" | "onTextInserted" | "onTextDeleted" | "onCanUndoChanged" | "onCanRedoChanged"
+>;
+
+type BufferProps = Pick<GtkTextViewProps, "enableUndo"> & BufferCallbackProps;
+
+export class TextBufferController<TBuffer extends Gtk.TextBuffer = Gtk.TextBuffer> {
+    private buffer: TBuffer | null = null;
+    private textChildren: TextContentChild[] = [];
+
+    constructor(
+        private readonly owner: Node & TextContentParent,
+        private readonly container: Gtk.TextView,
+        private readonly createBuffer: () => TBuffer,
+    ) {}
+
+    getBuffer(): TBuffer | null {
+        return this.buffer;
+    }
+
+    hasTextChildren(): boolean {
+        return this.textChildren.length > 0;
+    }
+
+    ensureBuffer(): TBuffer {
+        if (!this.buffer) {
+            this.buffer = this.createBuffer();
+            this.container.setBuffer(this.buffer);
+        }
+        return this.buffer;
+    }
+
+    applyOwnProps(oldProps: BufferProps | null, newProps: BufferProps): void {
+        const hasBufferProps =
+            newProps.enableUndo !== undefined ||
+            newProps.onBufferChanged !== undefined ||
+            newProps.onTextInserted !== undefined ||
+            newProps.onTextDeleted !== undefined ||
+            newProps.onCanUndoChanged !== undefined ||
+            newProps.onCanRedoChanged !== undefined;
+
+        if (!hasBufferProps && this.textChildren.length === 0) {
+            return;
+        }
+
+        const buffer = this.ensureBuffer();
+
+        if (hasChanged(oldProps, newProps, "enableUndo") && newProps.enableUndo !== undefined) {
+            buffer.setEnableUndo(newProps.enableUndo);
+        }
+
+        const signalHandlersChanged =
+            hasChanged(oldProps, newProps, "onBufferChanged") ||
+            hasChanged(oldProps, newProps, "onTextInserted") ||
+            hasChanged(oldProps, newProps, "onTextDeleted") ||
+            hasChanged(oldProps, newProps, "onCanUndoChanged") ||
+            hasChanged(oldProps, newProps, "onCanRedoChanged");
+
+        if (signalHandlersChanged) {
+            this.setSignalHandlersChanged(newProps);
+        }
+    }
+
+    private setSignalHandlersChanged(callbacks: BufferCallbackProps): void {
+        if (!this.buffer) return;
+
+        const buffer = this.buffer;
+        const { onBufferChanged, onTextInserted, onTextDeleted, onCanUndoChanged, onCanRedoChanged } = callbacks;
+
+        this.owner.signalStore.set(
+            this.owner,
+            buffer,
+            "changed",
+            onBufferChanged ? () => onBufferChanged(buffer) : null,
+        );
+
+        this.owner.signalStore.set(
+            this.owner,
+            buffer,
+            "insert-text",
+            onTextInserted
+                ? (location: Gtk.TextIter, text: string) => onTextInserted(buffer, location.getOffset(), text)
+                : null,
+        );
+
+        this.owner.signalStore.set(
+            this.owner,
+            buffer,
+            "delete-range",
+            onTextDeleted
+                ? (start: Gtk.TextIter, end: Gtk.TextIter) => onTextDeleted(buffer, start.getOffset(), end.getOffset())
+                : null,
+        );
+
+        this.owner.signalStore.set(
+            this.owner,
+            buffer,
+            "notify::can-undo",
+            onCanUndoChanged ? () => onCanUndoChanged(buffer.getCanUndo()) : null,
+        );
+
+        this.owner.signalStore.set(
+            this.owner,
+            buffer,
+            "notify::can-redo",
+            onCanRedoChanged ? () => onCanRedoChanged(buffer.getCanRedo()) : null,
+        );
+    }
+
+    isTextContentChild(child: Node): child is TextContentChild {
+        return (
+            child instanceof TextSegmentNode ||
+            child instanceof TextTagNode ||
+            child instanceof TextAnchorNode ||
+            child instanceof TextPaintableNode
+        );
+    }
+
+    appendChild(child: TextContentChild): void {
+        const buffer = this.ensureBuffer();
+
+        const wasMoved = this.textChildren.indexOf(child) !== -1;
+        if (wasMoved) {
+            const existingIndex = this.textChildren.indexOf(child);
+            const oldOffset = child.getBufferOffset();
+            const oldLength = child.getLength();
+
+            this.textChildren.splice(existingIndex, 1);
+
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+
+            this.updateChildOffsets(existingIndex);
+        }
+
+        const offset = this.getTotalLength();
+
+        this.textChildren.push(child);
+        child.setBufferOffset(offset);
+
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        } else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        } else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        } else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+
+        if (wasMoved) {
+            this.updateChildOffsets(0);
+            this.reapplyTagsFromOffset(0);
+        }
+    }
+
+    insertBefore(child: TextContentChild, before: TextContentChild): void {
+        const buffer = this.ensureBuffer();
+
+        const existingIndex = this.textChildren.indexOf(child);
+        if (existingIndex !== -1) {
+            const oldOffset = child.getBufferOffset();
+            const oldLength = child.getLength();
+
+            this.textChildren.splice(existingIndex, 1);
+
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+
+            this.updateChildOffsets(existingIndex);
+        }
+
+        const beforeIndex = this.textChildren.indexOf(before);
+        const insertIndex = beforeIndex !== -1 ? beforeIndex : this.textChildren.length;
+
+        let offset = 0;
+        for (let i = 0; i < insertIndex; i++) {
+            const c = this.textChildren[i];
+            if (c) offset += c.getLength();
+        }
+
+        this.textChildren.splice(insertIndex, 0, child);
+        child.setBufferOffset(offset);
+
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        } else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        } else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        } else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+
+        this.updateChildOffsets(0);
+        this.reapplyTagsFromOffset(0);
+    }
+
+    removeChild(child: TextContentChild): void {
+        const index = this.textChildren.indexOf(child);
+        if (index === -1) return;
+
+        const offset = child.getBufferOffset();
+        const length = child.getLength();
+
+        this.textChildren.splice(index, 1);
+
+        if (this.buffer && length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+
+        this.updateChildOffsets(index);
+        this.reapplyTagsFromOffset(offset);
+    }
+
+    private getTotalLength(): number {
+        let length = 0;
+        for (const child of this.textChildren) {
+            length += child.getLength();
+        }
+        return length;
+    }
+
+    private insertTextAtOffset(text: string, offset: number): void {
+        const buffer = this.buffer;
+        if (!buffer || text.length === 0) return;
+
+        const iter = new Gtk.TextIter();
+        buffer.getIterAtOffset(iter, offset);
+        buffer.insert(iter, text, text.length);
+    }
+
+    private deleteTextAtRange(start: number, end: number): void {
+        const buffer = this.buffer;
+        if (!buffer || start >= end) return;
+
+        const startIter = new Gtk.TextIter();
+        const endIter = new Gtk.TextIter();
+
+        buffer.getIterAtOffset(startIter, start);
+        buffer.getIterAtOffset(endIter, end);
+        buffer.delete(startIter, endIter);
+    }
+
+    private updateChildOffsets(startIndex: number): void {
+        let offset = 0;
+
+        for (let i = 0; i < startIndex; i++) {
+            const child = this.textChildren[i];
+            if (child) offset += child.getLength();
+        }
+
+        for (let i = startIndex; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                child.setBufferOffset(offset);
+                offset += child.getLength();
+            }
+        }
+    }
+
+    private reapplyAllTagsRecursive(children: TextContentChild[]): void {
+        for (const child of children) {
+            if (child instanceof TextTagNode) {
+                child.reapplyTag();
+                this.reapplyAllTagsRecursive(child.children);
+            }
+        }
+    }
+
+    private reapplyTagsFromOffset(fromOffset: number): void {
+        for (const child of this.textChildren) {
+            if (child instanceof TextTagNode) {
+                if (child.getBufferOffset() >= fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.children);
+                } else if (child.getBufferOffset() + child.getLength() > fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.children);
+                }
+            }
+        }
+    }
+
+    private findDirectChildContaining(offset: number): number {
+        for (let i = 0; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                const start = child.getBufferOffset();
+                const end = start + child.getLength();
+                if (offset >= start && offset <= end) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    onChildInserted(child: TextContentChild): void {
+        if (!this.buffer) return;
+
+        const text = child.getText();
+        if (text.length > 0) {
+            this.insertTextAtOffset(text, child.getBufferOffset());
+        }
+
+        const containingIndex = this.findDirectChildContaining(child.getBufferOffset());
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+
+        this.reapplyTagsFromOffset(child.getBufferOffset());
+    }
+
+    onChildRemoved(child: TextContentChild): void {
+        if (!this.buffer) return;
+
+        const offset = child.getBufferOffset();
+        const length = child.getLength();
+
+        if (length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+
+        const containingIndex = this.findDirectChildContaining(offset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+
+        this.reapplyTagsFromOffset(offset);
+    }
+
+    onChildTextChanged(child: TextSegmentNode, oldLength: number, _newLength: number): void {
+        if (!this.buffer) return;
+
+        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();
+        }
+    }
+}