@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/stack-page.d.ts

@@ -1 +1,21 @@
-export {};
+import type { StackPageProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import type { StackWidget } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class StackPageNode extends VirtualNode<StackPageProps, WidgetNode<StackWidget>, WidgetNode> {
+    private page;
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<StackWidget> | null): void;
+    appendChild(child: WidgetNode): void;
+    removeChild(child: WidgetNode): void;
+    commitUpdate(oldProps: StackPageProps | null, newProps: StackPageProps): void;
+    detachDeletedInstance(): void;
+    private getChildWidget;
+    private getParentWidget;
+    private applyOwnProps;
+    private onChildChange;
+    private addPage;
+    private removePage;
+}

package/dist/nodes/stack-page.js

@@ -1,18 +1,70 @@
-import { isObjectEqual } from "@gtkx/ffi";
 import * as Adw from "@gtkx/ffi/adw";
-import { registerNodeClass } from "../registry.js";
-import { hasChanged } from "./internal/utils.js";
-import { SlotNode } from "./slot.js";
-class StackPageNode extends SlotNode {
-    static priority = 1;
+import * as Gtk from "@gtkx/ffi/gtk";
+import { hasChanged } from "./internal/props.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class StackPageNode extends VirtualNode {
     page = null;
-    static matches(type) {
-        return type === "StackPage";
+    isValidChild(child) {
+        return child instanceof WidgetNode;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
+    isValidParent(parent) {
+        return (parent instanceof WidgetNode &&
+            (parent.container instanceof Gtk.Stack || parent.container instanceof Adw.ViewStack));
+    }
+    setParent(parent) {
+        const previousParent = this.parent;
+        if (previousParent && !parent) {
+            const childWidget = this.children[0]?.container ?? null;
+            if (childWidget) {
+                this.removePage(childWidget);
+            }
+            this.page = null;
+        }
+        super.setParent(parent);
+        if (parent && this.children[0]) {
+            this.onChildChange(null);
+        }
+    }
+    appendChild(child) {
+        const oldChildWidget = this.children[0]?.container ?? null;
+        super.appendChild(child);
+        if (this.parent) {
+            this.onChildChange(oldChildWidget);
+        }
+    }
+    removeChild(child) {
+        const oldChildWidget = child.container;
+        super.removeChild(child);
+        if (this.parent && oldChildWidget) {
+            this.onChildChange(oldChildWidget);
+        }
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
         this.applyOwnProps(oldProps, newProps);
     }
+    detachDeletedInstance() {
+        const childWidget = this.children[0]?.container ?? null;
+        if (childWidget && this.parent) {
+            this.removePage(childWidget);
+        }
+        this.page = null;
+        super.detachDeletedInstance();
+    }
+    getChildWidget() {
+        const child = this.children[0];
+        if (!child) {
+            throw new Error("Expected child widget to be set on StackPageNode");
+        }
+        return child.container;
+    }
+    getParentWidget() {
+        if (!this.parent) {
+            throw new Error("Expected parent widget to be set on StackPageNode");
+        }
+        return this.parent.container;
+    }
     applyOwnProps(oldProps, newProps) {
         if (!this.page) {
             return;
@@ -38,13 +90,13 @@ class StackPageNode extends SlotNode {
     }
     onChildChange(oldChild) {
         this.removePage(oldChild);
-        if (this.child) {
+        if (this.children[0]) {
             this.addPage();
         }
     }
     addPage() {
-        const child = this.getChild();
-        const parent = this.getParent();
+        const child = this.getChildWidget();
+        const parent = this.getParentWidget();
         let page;
         if (parent instanceof Adw.ViewStack) {
             if (this.props.title && this.props.iconName) {
@@ -72,17 +124,16 @@ class StackPageNode extends SlotNode {
             }
         }
         this.page = page;
-        this.updateProps(null, this.props);
+        this.commitUpdate(null, this.props);
     }
     removePage(oldChild) {
-        const parent = this.getParent();
+        const parent = this.getParentWidget();
         if (!oldChild) {
             return;
         }
         const currentParent = oldChild.getParent();
-        if (currentParent && isObjectEqual(currentParent, parent)) {
+        if (currentParent && currentParent === parent) {
             parent.remove(oldChild);
         }
     }
 }
-registerNodeClass(StackPageNode);

package/dist/nodes/stack.d.ts

@@ -1 +1,12 @@
+import type { AdwViewStackProps, GtkStackProps } from "../jsx.js";
+import type { StackWidget } from "../registry.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["page", "onPageChanged"];
+type StackProps = Omit<Pick<GtkStackProps | AdwViewStackProps, (typeof OWN_PROPS)[number]>, "onPageChanged"> & {
+    onPageChanged?: ((page: string | null, self: StackWidget) => void) | null;
+};
+export declare class StackNode extends WidgetNode<StackWidget, StackProps> {
+    commitUpdate(oldProps: StackProps | null, newProps: StackProps): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/stack.js

@@ -1,38 +1,20 @@
-import { STACK_CLASSES } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = ["page", "onPageChanged"];
-class StackNode extends WidgetNode {
-    static priority = 1;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass(STACK_CLASSES, containerOrClass);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+export class StackNode extends WidgetNode {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.applyOwnProps(oldProps, newProps);
     }
     applyOwnProps(oldProps, newProps) {
         if (newProps.page && this.container.getVisibleChildName() !== newProps.page) {
-            const page = newProps.page;
-            scheduleAfterCommit(() => {
-                if (this.container.getChildByName(page)) {
-                    this.container.setVisibleChildName(page);
-                }
-            }, CommitPriority.NORMAL);
+            if (this.container.getChildByName(newProps.page)) {
+                this.container.setVisibleChildName(newProps.page);
+            }
         }
         if (hasChanged(oldProps, newProps, "onPageChanged")) {
             const { onPageChanged } = newProps;
-            if (onPageChanged) {
-                this.signalStore.set(this, this.container, "notify::visible-child-name", (self) => {
-                    onPageChanged(self.getVisibleChildName(), self);
-                });
-            }
-            else {
-                this.signalStore.set(this, this.container, "notify::visible-child-name", null);
-            }
+            this.signalStore.set(this, this.container, "notify::visible-child-name", onPageChanged ? (self) => onPageChanged(self.getVisibleChildName(), self) : undefined);
         }
     }
 }
-registerNodeClass(StackNode);

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

@@ -1,41 +1,22 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { ReactNode } from "react";
+import type { TextAnchorProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { type TextContentParent } from "./text-content.js";
 import { VirtualNode } from "./virtual.js";
-/**
- * Props for the TextAnchor virtual element.
- *
- * Used to declaratively embed widgets within text content in a TextBuffer.
- * The anchor is placed at the current position in the text flow.
- *
- * @example
- * ```tsx
- * <GtkTextView>
- *     <x.TextBuffer>
- *         Click here: <x.TextAnchor>
- *             <GtkButton label="Click me" />
- *         </x.TextAnchor> to continue.
- *     </x.TextBuffer>
- * </GtkTextView>
- * ```
- */
-export type TextAnchorProps = {
-    /** The widget to embed at this anchor position */
-    children?: ReactNode;
-};
-export declare class TextAnchorNode extends VirtualNode<TextAnchorProps> {
-    static priority: number;
+import { WidgetNode } from "./widget.js";
+export declare class TextAnchorNode extends VirtualNode<TextAnchorProps, Node & TextContentParent, WidgetNode> {
     private textView;
     private buffer;
     private anchor;
-    private widgetChild;
-    bufferOffset: number;
-    static matches(type: string): boolean;
+    private bufferOffset;
+    getBufferOffset(): number;
+    setBufferOffset(offset: number): void;
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
     getLength(): number;
     getText(): string;
     setTextViewAndBuffer(textView: Gtk.TextView, buffer: Gtk.TextBuffer): void;
     private setupAnchor;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    unmount(): void;
+    appendChild(child: WidgetNode): void;
+    detachDeletedInstance(): void;
 }

package/dist/nodes/text-anchor.js

@@ -1,23 +1,30 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
+import { TEXT_OBJECT_REPLACEMENT } from "./text-content.js";
+import { isTextContentParent } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
-const PLACEHOLDER = "\uFFFC";
 export class TextAnchorNode extends VirtualNode {
-    static priority = 1;
     textView = null;
     buffer = null;
     anchor = null;
-    widgetChild = null;
     bufferOffset = 0;
-    static matches(type) {
-        return type === "TextAnchor";
+    getBufferOffset() {
+        return this.bufferOffset;
+    }
+    setBufferOffset(offset) {
+        this.bufferOffset = offset;
+    }
+    isValidChild(child) {
+        return child instanceof WidgetNode;
+    }
+    isValidParent(parent) {
+        return isTextContentParent(parent);
     }
     getLength() {
         return 1;
     }
     getText() {
-        return PLACEHOLDER;
+        return TEXT_OBJECT_REPLACEMENT;
     }
     setTextViewAndBuffer(textView, buffer) {
         this.textView = textView;
@@ -30,30 +37,21 @@ export class TextAnchorNode extends VirtualNode {
         const iter = new Gtk.TextIter();
         this.buffer.getIterAtOffset(iter, this.bufferOffset);
         this.anchor = this.buffer.createChildAnchor(iter);
-        if (this.widgetChild?.container && this.anchor) {
-            this.textView.addChildAtAnchor(this.widgetChild.container, this.anchor);
+        const widgetChild = this.children[0];
+        if (widgetChild?.container && this.anchor) {
+            this.textView.addChildAtAnchor(widgetChild.container, this.anchor);
         }
     }
     appendChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`TextAnchor can only contain widget children, got '${child.typeName}'`);
-        }
-        this.widgetChild = child;
+        super.appendChild(child);
         if (this.textView && this.anchor && child.container) {
             this.textView.addChildAtAnchor(child.container, this.anchor);
         }
     }
-    removeChild(child) {
-        if (child === this.widgetChild) {
-            this.widgetChild = null;
-        }
-    }
-    unmount() {
+    detachDeletedInstance() {
         this.anchor = null;
-        this.widgetChild = null;
         this.buffer = null;
         this.textView = null;
-        super.unmount();
+        super.detachDeletedInstance();
     }
 }
-registerNodeClass(TextAnchorNode);

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

@@ -2,6 +2,7 @@ import type { TextAnchorNode } from "./text-anchor.js";
 import type { TextPaintableNode } from "./text-paintable.js";
 import type { TextSegmentNode } from "./text-segment.js";
 import type { TextTagNode } from "./text-tag.js";
+export declare const TEXT_OBJECT_REPLACEMENT = "\uFFFC";
 export type TextContentChild = TextSegmentNode | TextTagNode | TextAnchorNode | TextPaintableNode;
 export type TextContentParent = {
     onChildInserted(child: TextContentChild): void;

package/dist/nodes/text-content.js

@@ -1 +1 @@
-export {};
+export const TEXT_OBJECT_REPLACEMENT = "\uFFFC";

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

@@ -1,23 +1,18 @@
-import type * as Gdk from "@gtkx/ffi/gdk";
 import * as Gtk from "@gtkx/ffi/gtk";
+import type { TextPaintableProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { type TextContentParent } from "./text-content.js";
 import { VirtualNode } from "./virtual.js";
-/**
- * Props for the TextPaintable virtual element.
- *
- * Used to embed inline images or icons within text content in a GtkTextView.
- */
-export type TextPaintableProps = {
-    /** The paintable (image, icon, etc.) to embed inline with the text */
-    paintable: Gdk.Paintable;
-};
-export declare class TextPaintableNode extends VirtualNode<TextPaintableProps> {
-    static priority: number;
+export declare class TextPaintableNode extends VirtualNode<TextPaintableProps, Node & TextContentParent, never> {
+    isValidChild(_child: Node): boolean;
+    isValidParent(parent: Node): boolean;
     private buffer;
-    bufferOffset: number;
-    static matches(type: string): boolean;
+    private bufferOffset;
+    getBufferOffset(): number;
+    setBufferOffset(offset: number): void;
     getLength(): number;
     getText(): string;
     setTextViewAndBuffer(_textView: Gtk.TextView, buffer: Gtk.TextBuffer): void;
     private insertPaintable;
-    unmount(): void;
+    detachDeletedInstance(): void;
 }

package/dist/nodes/text-paintable.js

@@ -1,19 +1,27 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
+import { TEXT_OBJECT_REPLACEMENT } from "./text-content.js";
+import { isTextContentParent } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
-const PLACEHOLDER = "\uFFFC";
 export class TextPaintableNode extends VirtualNode {
-    static priority = 1;
+    isValidChild(_child) {
+        return false;
+    }
+    isValidParent(parent) {
+        return isTextContentParent(parent);
+    }
     buffer = null;
     bufferOffset = 0;
-    static matches(type) {
-        return type === "TextPaintable";
+    getBufferOffset() {
+        return this.bufferOffset;
+    }
+    setBufferOffset(offset) {
+        this.bufferOffset = offset;
     }
     getLength() {
         return 1;
     }
     getText() {
-        return PLACEHOLDER;
+        return TEXT_OBJECT_REPLACEMENT;
     }
     setTextViewAndBuffer(_textView, buffer) {
         this.buffer = buffer;
@@ -26,9 +34,8 @@ export class TextPaintableNode extends VirtualNode {
         this.buffer.getIterAtOffset(iter, this.bufferOffset);
         this.buffer.insertPaintable(iter, this.props.paintable);
     }
-    unmount() {
+    detachDeletedInstance() {
         this.buffer = null;
-        super.unmount();
+        super.detachDeletedInstance();
     }
 }
-registerNodeClass(TextPaintableNode);

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

@@ -1,15 +1,17 @@
+import type { TextSegmentProps } from "../jsx.js";
+import type { Node } from "../node.js";
 import type { TextContentParent } from "./text-content.js";
 import { VirtualNode } from "./virtual.js";
-export type TextSegmentProps = {
-    text: string;
-};
-export declare class TextSegmentNode extends VirtualNode<TextSegmentProps> {
-    static priority: number;
-    private parent;
-    bufferOffset: number;
-    static matches(type: string): boolean;
-    setParent(parent: TextContentParent): void;
+type TextSegmentParent = Node & TextContentParent;
+export declare class TextSegmentNode extends VirtualNode<TextSegmentProps, TextSegmentParent, never> {
+    private bufferOffset;
+    getBufferOffset(): number;
+    setBufferOffset(offset: number): void;
+    isValidChild(_child: Node): boolean;
+    isValidParent(parent: Node): boolean;
     getText(): string;
     getLength(): number;
-    updateProps(oldProps: TextSegmentProps | null, newProps: TextSegmentProps): void;
+    commitUpdate(oldProps: TextSegmentProps | null, newProps: TextSegmentProps): void;
 }
+export declare function isTextContentParent(node: Node): node is TextSegmentParent;
+export {};

package/dist/nodes/text-segment.js

@@ -1,15 +1,18 @@
-import { registerNodeClass } from "../registry.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 export class TextSegmentNode extends VirtualNode {
-    static priority = 1;
-    parent = null;
     bufferOffset = 0;
-    static matches(type) {
-        return type === "TextSegment";
+    getBufferOffset() {
+        return this.bufferOffset;
     }
-    setParent(parent) {
-        this.parent = parent;
+    setBufferOffset(offset) {
+        this.bufferOffset = offset;
+    }
+    isValidChild(_child) {
+        return false;
+    }
+    isValidParent(parent) {
+        return isTextContentParent(parent);
     }
     getText() {
         return this.props.text;
@@ -17,13 +20,18 @@ export class TextSegmentNode extends VirtualNode {
     getLength() {
         return this.props.text.length;
     }
-    updateProps(oldProps, newProps) {
+    commitUpdate(oldProps, newProps) {
         const oldText = oldProps?.text ?? "";
         const newText = newProps.text;
-        super.updateProps(oldProps, newProps);
+        super.commitUpdate(oldProps, newProps);
         if (hasChanged(oldProps, newProps, "text") && this.parent) {
             this.parent.onChildTextChanged(this, oldText.length, newText.length);
         }
     }
 }
-registerNodeClass(TextSegmentNode);
+export function isTextContentParent(node) {
+    const candidate = node;
+    return (typeof candidate.onChildInserted === "function" &&
+        typeof candidate.onChildRemoved === "function" &&
+        typeof candidate.onChildTextChanged === "function");
+}

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

@@ -1,136 +1,37 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type * as Pango from "@gtkx/ffi/pango";
-import type { ReactNode } from "react";
+import type { TextTagProps } from "../jsx.js";
 import type { Node } from "../node.js";
 import type { TextContentChild, TextContentParent } from "./text-content.js";
 import { TextSegmentNode } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
-/**
- * Props for the TextTag virtual element.
- *
- * Used to declaratively define and apply text formatting to content within a TextBuffer.
- *
- * @example
- * ```tsx
- * <GtkTextView>
- *     <x.TextBuffer>
- *         Hello <x.TextTag id="bold" weight={Pango.Weight.BOLD}>bold</x.TextTag> world
- *     </x.TextBuffer>
- * </GtkTextView>
- * ```
- */
-export type TextTagProps = {
-    /** Unique identifier for this tag in the tag table */
-    id: string;
-    /** Priority of this tag (higher wins when multiple tags affect same property) */
-    priority?: number;
-    /** Background color as a string (e.g., "red", "#ff0000") */
-    background?: string;
-    /** Whether the background fills the entire line height */
-    backgroundFullHeight?: boolean;
-    /** Foreground (text) color as a string */
-    foreground?: string;
-    /** Font family name (e.g., "Sans", "Monospace") */
-    family?: string;
-    /** Font description string (e.g., "Sans Italic 12") */
-    font?: string;
-    /** Font size in points */
-    sizePoints?: number;
-    /** Font size in Pango units */
-    size?: number;
-    /** Font size scale factor relative to default */
-    scale?: number;
-    /** Font weight (use Pango.Weight constants) */
-    weight?: Pango.Weight | number;
-    /** Font style (use Pango.Style constants) */
-    style?: Pango.Style;
-    /** Font stretch (use Pango.Stretch constants) */
-    stretch?: Pango.Stretch;
-    /** Font variant (use Pango.Variant constants) */
-    variant?: Pango.Variant;
-    /** Whether to strike through the text */
-    strikethrough?: boolean;
-    /** Underline style (use Pango.Underline constants) */
-    underline?: Pango.Underline;
-    /** Overline style (use Pango.Overline constants) */
-    overline?: Pango.Overline;
-    /** Offset of text above baseline in Pango units (negative = below) */
-    rise?: number;
-    /** Extra spacing between characters in Pango units */
-    letterSpacing?: number;
-    /** Factor to scale line height by */
-    lineHeight?: number;
-    /** Left margin in pixels */
-    leftMargin?: number;
-    /** Right margin in pixels */
-    rightMargin?: number;
-    /** Paragraph indent in pixels (negative = hanging) */
-    indent?: number;
-    /** Pixels of blank space above paragraphs */
-    pixelsAboveLines?: number;
-    /** Pixels of blank space below paragraphs */
-    pixelsBelowLines?: number;
-    /** Pixels of blank space between wrapped lines */
-    pixelsInsideWrap?: number;
-    /** Text justification */
-    justification?: Gtk.Justification;
-    /** Text direction */
-    direction?: Gtk.TextDirection;
-    /** Wrap mode for line breaks */
-    wrapMode?: Gtk.WrapMode;
-    /** Whether the text can be modified */
-    editable?: boolean;
-    /** Whether the text is invisible/hidden */
-    invisible?: boolean;
-    /** Whether breaks are allowed */
-    allowBreaks?: boolean;
-    /** Whether to insert hyphens at breaks */
-    insertHyphens?: boolean;
-    /** Whether font fallback is enabled */
-    fallback?: boolean;
-    /** Whether margins accumulate */
-    accumulativeMargin?: boolean;
-    /** Paragraph background color as a string */
-    paragraphBackground?: string;
-    /** How to render invisible characters */
-    showSpaces?: Pango.ShowFlags;
-    /** How to transform text for display */
-    textTransform?: Pango.TextTransform;
-    /** OpenType font features as a string */
-    fontFeatures?: string;
-    /** Language code (e.g., "en-US") */
-    language?: string;
-    /** Text content and nested TextTag children */
-    children?: ReactNode;
-};
-export declare class TextTagNode extends VirtualNode<TextTagProps> implements TextContentParent {
-    static priority: number;
+type TextTagParent = Node & TextContentParent;
+export declare class TextTagNode extends VirtualNode<TextTagProps, TextTagParent, TextContentChild> implements TextContentParent {
     private buffer;
     private tag;
-    private children;
-    private parent;
-    bufferOffset: number;
-    static matches(type: string): boolean;
-    setParent(parent: TextContentParent): void;
+    private bufferOffset;
+    getBufferOffset(): number;
+    setBufferOffset(offset: number): void;
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    appendChild(child: TextContentChild): void;
+    removeChild(child: TextContentChild): void;
+    insertBefore(child: TextContentChild, before: TextContentChild): void;
+    commitUpdate(oldProps: TextTagProps | null, newProps: TextTagProps): void;
+    detachDeletedInstance(): void;
     setBuffer(buffer: Gtk.TextBuffer): void;
     hasBuffer(): boolean;
-    private setupTag;
-    private applyStyleProps;
     getText(): string;
     getLength(): number;
-    getChildren(): TextContentChild[];
-    private applyTagToRange;
-    private removeTagFromBuffer;
     reapplyTag(): void;
-    private updateChildOffsets;
     onChildInserted(child: TextContentChild): void;
     onChildRemoved(child: TextContentChild): void;
     onChildTextChanged(child: TextSegmentNode, oldLength: number, newLength: number): void;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
+    private setupTag;
+    private applyOwnProps;
+    private applyStyleProps;
+    private applyTagToRange;
+    private removeTagFromBuffer;
+    private updateChildOffsets;
     private isTextContentChild;
-    private setChildParent;
-    updateProps(oldProps: TextTagProps | null, newProps: TextTagProps): void;
-    unmount(): void;
 }
+export {};