@gtkx/react 0.14.0 → 0.16.0

package/dist/generated/jsx.js

@@ -9118,3 +9118,478 @@ export const AdwWindowTitle = "AdwWindowTitle";
  * `AdwWrapBox` uses the `GTK_ACCESSIBLE_ROLE_GROUP` role.
  */
 export const AdwWrapBox = "AdwWrapBox";
+/**
+ * An event controller to initiate Drag-And-Drop operations.
+ *
+ * `GtkDragSource` can be set up with the necessary
+ * ingredients for a DND operation ahead of time. This includes
+ * the source for the data that is being transferred, in the form
+ * of a {@link Gdk.ContentProvider}, the desired action, and the icon to
+ * use during the drag operation. After setting it up, the drag
+ * source must be added to a widget as an event controller, using
+ * {@link Gtk.Widget.add_controller}.
+ *
+ * ```c
+ * static void
+ * my_widget_init (MyWidget *self)
+ * {
+ *   GtkDragSource *drag_source = gtk_drag_source_new ();
+ *
+ *   g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
+ *   g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);
+ *
+ *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
+ * }
+ * ```
+ *
+ * Setting up the content provider and icon ahead of time only makes
+ * sense when the data does not change. More commonly, you will want
+ * to set them up just in time. To do so, `GtkDragSource` has
+ * {@link Gtk.DragSource.:prepare} and {@link Gtk.DragSource.:drag-begin}
+ * signals.
+ *
+ * The ::prepare signal is emitted before a drag is started, and
+ * can be used to set the content provider and actions that the
+ * drag should be started with.
+ *
+ * ```c
+ * static GdkContentProvider *
+ * on_drag_prepare (GtkDragSource *source,
+ *                  double         x,
+ *                  double         y,
+ *                  MyWidget      *self)
+ * {
+ *   // This widget supports two types of content: GFile objects
+ *   // and GdkPixbuf objects; GTK will handle the serialization
+ *   // of these types automatically
+ *   GFile *file = my_widget_get_file (self);
+ *   GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);
+ *
+ *   return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
+ *       gdk_content_provider_new_typed (G_TYPE_FILE, file),
+ *       gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
+ *     }, 2);
+ * }
+ * ```
+ *
+ * The ::drag-begin signal is emitted after the `GdkDrag` object has
+ * been created, and can be used to set up the drag icon.
+ *
+ * ```c
+ * static void
+ * on_drag_begin (GtkDragSource *source,
+ *                GdkDrag       *drag,
+ *                MyWidget      *self)
+ * {
+ *   // Set the widget as the drag icon
+ *   GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
+ *   gtk_drag_source_set_icon (source, paintable, 0, 0);
+ *   g_object_unref (paintable);
+ * }
+ * ```
+ *
+ * During the DND operation, `GtkDragSource` emits signals that
+ * can be used to obtain updates about the status of the operation,
+ * but it is not normally necessary to connect to any signals,
+ * except for one case: when the supported actions include
+ * %GDK_ACTION_MOVE, you need to listen for the
+ * {@link Gtk.DragSource.:drag-end} signal and delete the
+ * data after it has been transferred.
+ */
+export const GtkDragSource = "GtkDragSource";
+/**
+ * An event controller tracking the pointer during Drag-and-Drop operations.
+ *
+ * It is modeled after {@link Gtk.EventControllerMotion} so if you
+ * have used that, this should feel really familiar.
+ *
+ * This controller is not able to accept drops, use {@link Gtk.DropTarget}
+ * for that purpose.
+ */
+export const GtkDropControllerMotion = "GtkDropControllerMotion";
+/**
+ * An event controller to receive Drag-and-Drop operations.
+ *
+ * The most basic way to use a `GtkDropTarget` to receive drops on a
+ * widget is to create it via {@link Gtk.DropTarget.new}, passing in the
+ * `GType` of the data you want to receive and connect to the
+ * {@link Gtk.DropTarget.:drop} signal to receive the data:
+ *
+ * ```c
+ * static gboolean
+ * on_drop (GtkDropTarget *target,
+ *          const GValue  *value,
+ *          double         x,
+ *          double         y,
+ *          gpointer       data)
+ * {
+ *   MyWidget *self = data;
+ *
+ *   // Call the appropriate setter depending on the type of data
+ *   // that we received
+ *   if (G_VALUE_HOLDS (value, G_TYPE_FILE))
+ *     my_widget_set_file (self, g_value_get_object (value));
+ *   else if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
+ *     my_widget_set_pixbuf (self, g_value_get_object (value));
+ *   else
+ *     return FALSE;
+ *
+ *   return TRUE;
+ * }
+ *
+ * static void
+ * my_widget_init (MyWidget *self)
+ * {
+ *   GtkDropTarget *target =
+ *     gtk_drop_target_new (G_TYPE_INVALID, GDK_ACTION_COPY);
+ *
+ *   // This widget accepts two types of drop types: GFile objects
+ *   // and GdkPixbuf objects
+ *   gtk_drop_target_set_gtypes (target, (GType [2]) {
+ *     G_TYPE_FILE,
+ *     GDK_TYPE_PIXBUF,
+ *   }, 2);
+ *
+ *   g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
+ *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
+ * }
+ * ```
+ *
+ * `GtkDropTarget` supports more options, such as:
+ *
+ *  * rejecting potential drops via the {@link Gtk.DropTarget.:accept} signal
+ *    and the {@link Gtk.DropTarget.reject} function to let other drop
+ *    targets handle the drop
+ *  * tracking an ongoing drag operation before the drop via the
+ *    {@link Gtk.DropTarget.:enter}, {@link Gtk.DropTarget.:motion} and
+ *    {@link Gtk.DropTarget.:leave} signals
+ *  * configuring how to receive data by setting the
+ *    {@link Gtk.DropTarget.preload} property and listening for its
+ *    availability via the {@link Gtk.DropTarget.value} property
+ *
+ * However, `GtkDropTarget` is ultimately modeled in a synchronous way
+ * and only supports data transferred via `GType`. If you want full control
+ * over an ongoing drop, the {@link Gtk.DropTargetAsync} object gives you
+ * this ability.
+ *
+ * While a pointer is dragged over the drop target's widget and the drop
+ * has not been rejected, that widget will receive the
+ * %GTK_STATE_FLAG_DROP_ACTIVE state, which can be used to style the widget.
+ *
+ * If you are not interested in receiving the drop, but just want to update
+ * UI state during a Drag-and-Drop operation (e.g. switching tabs), you can
+ * use {@link Gtk.DropControllerMotion}.
+ */
+export const GtkDropTarget = "GtkDropTarget";
+/**
+ * An event controller to receive Drag-and-Drop operations, asynchronously.
+ *
+ * It is the more complete but also more complex method of handling drop
+ * operations compared to {@link Gtk.DropTarget}, and you should only use
+ * it if `GtkDropTarget` doesn't provide all the features you need.
+ *
+ * To use a `GtkDropTargetAsync` to receive drops on a widget, you create
+ * a `GtkDropTargetAsync` object, configure which data formats and actions
+ * you support, connect to its signals, and then attach it to the widget
+ * with {@link Gtk.Widget.add_controller}.
+ *
+ * During a drag operation, the first signal that a `GtkDropTargetAsync`
+ * emits is {@link Gtk.DropTargetAsync.:accept}, which is meant to determine
+ * whether the target is a possible drop site for the ongoing drop. The
+ * default handler for the ::accept signal accepts the drop if it finds
+ * a compatible data format and an action that is supported on both sides.
+ *
+ * If it is, and the widget becomes a target, you will receive a
+ * {@link Gtk.DropTargetAsync.:drag-enter} signal, followed by
+ * {@link Gtk.DropTargetAsync.:drag-motion} signals as the pointer moves,
+ * optionally a {@link Gtk.DropTargetAsync.:drop} signal when a drop happens,
+ * and finally a {@link Gtk.DropTargetAsync.:drag-leave} signal when the
+ * pointer moves off the widget.
+ *
+ * The ::drag-enter and ::drag-motion handler return a `GdkDragAction`
+ * to update the status of the ongoing operation. The ::drop handler
+ * should decide if it ultimately accepts the drop and if it does, it
+ * should initiate the data transfer and finish the operation by calling
+ * {@link Gdk.Drop.finish}.
+ *
+ * Between the ::drag-enter and ::drag-leave signals the widget is a
+ * current drop target, and will receive the %GTK_STATE_FLAG_DROP_ACTIVE
+ * state, which can be used by themes to style the widget as a drop target.
+ */
+export const GtkDropTargetAsync = "GtkDropTargetAsync";
+/**
+ * Tracks keyboard focus.
+ *
+ * The event controller offers {@link Gtk.EventControllerFocus.:enter}
+ * and {@link Gtk.EventControllerFocus.:leave} signals, as well as
+ * {@link Gtk.EventControllerFocus.is-focus} and
+ * {@link Gtk.EventControllerFocus.contains-focus} properties
+ * which are updated to reflect focus changes inside the widget hierarchy
+ * that is rooted at the controllers widget.
+ */
+export const GtkEventControllerFocus = "GtkEventControllerFocus";
+/** Provides access to key events. */
+export const GtkEventControllerKey = "GtkEventControllerKey";
+/**
+ * Provides raw access to the event stream.
+ *
+ * It should only be used as a last resort if none of the other event
+ * controllers or gestures do the job.
+ */
+export const GtkEventControllerLegacy = "GtkEventControllerLegacy";
+/**
+ * Tracks the pointer position.
+ *
+ * The event controller offers {@link Gtk.EventControllerMotion.:enter}
+ * and {@link Gtk.EventControllerMotion.:leave} signals, as well as
+ * {@link Gtk.EventControllerMotion.is-pointer} and
+ * {@link Gtk.EventControllerMotion.contains-pointer} properties
+ * which are updated to reflect changes in the pointer position as it
+ * moves over the widget.
+ */
+export const GtkEventControllerMotion = "GtkEventControllerMotion";
+/**
+ * Handles scroll events.
+ *
+ * It is capable of handling both discrete and continuous scroll
+ * events from mice or touchpads, abstracting them both with the
+ * {@link Gtk.EventControllerScroll.:scroll} signal. Deltas in
+ * the discrete case are multiples of 1.
+ *
+ * In the case of continuous scroll events, `GtkEventControllerScroll`
+ * encloses all {@link Gtk.EventControllerScroll.:scroll} emissions
+ * between two {@link Gtk.EventControllerScroll.:scroll-begin} and
+ * {@link Gtk.EventControllerScroll.:scroll-end} signals.
+ *
+ * The behavior of the event controller can be modified by the flags
+ * given at creation time, or modified at a later point through
+ * {@link Gtk.EventControllerScroll.set_flags} (e.g. because the scrolling
+ * conditions of the widget changed).
+ *
+ * The controller can be set up to emit motion for either/both vertical
+ * and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
+ * %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
+ * If any axis is disabled, the respective {@link Gtk.EventControllerScroll.:scroll}
+ * delta will be 0. Vertical scroll events will be translated to horizontal
+ * motion for the devices incapable of horizontal scrolling.
+ *
+ * The event controller can also be forced to emit discrete events on all
+ * devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
+ * to implement discrete actions triggered through scroll events (e.g.
+ * switching across combobox options).
+ *
+ * The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
+ * {@link Gtk.EventControllerScroll.:decelerate} signal, emitted at the end
+ * of scrolling with two X/Y velocity arguments that are consistent with the
+ * motion that was received.
+ */
+export const GtkEventControllerScroll = "GtkEventControllerScroll";
+/**
+ * Recognizes click gestures.
+ *
+ * It is able to recognize multiple clicks on a nearby zone, which
+ * can be listened for through the {@link Gtk.GestureClick.:pressed}
+ * signal. Whenever time or distance between clicks exceed the GTK
+ * defaults, {@link Gtk.GestureClick.:stopped} is emitted, and the
+ * click counter is reset.
+ */
+export const GtkGestureClick = "GtkGestureClick";
+/**
+ * Recognizes drag gestures.
+ *
+ * The drag operation itself can be tracked throughout the
+ * {@link Gtk.GestureDrag.:drag-begin},
+ * {@link Gtk.GestureDrag.:drag-update} and
+ * {@link Gtk.GestureDrag.:drag-end} signals, and the relevant
+ * coordinates can be extracted through
+ * {@link Gtk.GestureDrag.get_offset} and
+ * {@link Gtk.GestureDrag.get_start_point}.
+ */
+export const GtkGestureDrag = "GtkGestureDrag";
+/**
+ * Recognizes long press gestures.
+ *
+ * This gesture is also known as “Press and Hold”.
+ *
+ * When the timeout is exceeded, the gesture is triggering the
+ * {@link Gtk.GestureLongPress.:pressed} signal.
+ *
+ * If the touchpoint is lifted before the timeout passes, or if
+ * it drifts too far of the initial press point, the
+ * {@link Gtk.GestureLongPress.:cancelled} signal will be emitted.
+ *
+ * How long the timeout is before the ::pressed signal gets emitted is
+ * determined by the {@link Gtk.Settings.gtk-long-press-time} setting.
+ * It can be modified by the {@link Gtk.GestureLongPress.delay-factor}
+ * property.
+ */
+export const GtkGestureLongPress = "GtkGestureLongPress";
+/**
+ * Recognizes pan gestures.
+ *
+ * These are drags that are locked to happen along one axis. The axis
+ * that a `GtkGesturePan` handles is defined at construct time, and
+ * can be changed through {@link Gtk.GesturePan.set_orientation}.
+ *
+ * When the gesture starts to be recognized, `GtkGesturePan` will
+ * attempt to determine as early as possible whether the sequence
+ * is moving in the expected direction, and denying the sequence if
+ * this does not happen.
+ *
+ * Once a panning gesture along the expected axis is recognized,
+ * the {@link Gtk.GesturePan.:pan} signal will be emitted as input
+ * events are received, containing the offset in the given axis.
+ */
+export const GtkGesturePan = "GtkGesturePan";
+/**
+ * Recognizes 2-finger rotation gestures.
+ *
+ * Whenever the angle between both handled sequences changes, the
+ * {@link Gtk.GestureRotate.:angle-changed} signal is emitted.
+ */
+export const GtkGestureRotate = "GtkGestureRotate";
+/**
+ * A `GtkGesture` subclass optimized for singe-touch and mouse gestures.
+ *
+ * Under interaction, these gestures stick to the first interacting sequence,
+ * which is accessible through {@link Gtk.GestureSingle.get_current_sequence}
+ * while the gesture is being interacted with.
+ *
+ * By default gestures react to both %GDK_BUTTON_PRIMARY and touch events.
+ * {@link Gtk.GestureSingle.set_touch_only} can be used to change the
+ * touch behavior. Callers may also specify a different mouse button number
+ * to interact with through {@link Gtk.GestureSingle.set_button}, or react
+ * to any mouse button by setting it to 0. While the gesture is active, the
+ * button being currently pressed can be known through
+ * {@link Gtk.GestureSingle.get_current_button}.
+ */
+export const GtkGestureSingle = "GtkGestureSingle";
+/**
+ * Recognizes tablet stylus input.
+ *
+ * The provided signals just relay the basic information of the
+ * stylus events.
+ */
+export const GtkGestureStylus = "GtkGestureStylus";
+/**
+ * Recognizes swipe gestures.
+ *
+ * After a press/move/.../move/release sequence happens, the
+ * {@link Gtk.GestureSwipe.:swipe} signal will be emitted,
+ * providing the velocity and directionality of the sequence
+ * at the time it was lifted.
+ *
+ * If the velocity is desired in intermediate points,
+ * {@link Gtk.GestureSwipe.get_velocity} can be called in a
+ * {@link Gtk.Gesture.:update} handler.
+ *
+ * All velocities are reported in pixels/sec units.
+ */
+export const GtkGestureSwipe = "GtkGestureSwipe";
+/**
+ * Recognizes 2-finger pinch/zoom gestures.
+ *
+ * Whenever the distance between both tracked sequences changes, the
+ * {@link Gtk.GestureZoom.:scale-changed} signal is emitted to report
+ * the scale factor.
+ */
+export const GtkGestureZoom = "GtkGestureZoom";
+/**
+ * Handles input from the pads found in drawing tablets.
+ *
+ * Pads are the collection of buttons and tactile sensors often found around
+ * the stylus-sensitive area.
+ *
+ * These buttons and sensors have no implicit meaning, and by default they
+ * perform no action. `GtkPadController` is provided to map those to
+ * {@link Gio.Action} objects, thus letting the application give them a more
+ * semantic meaning.
+ *
+ * Buttons and sensors are not constrained to triggering a single action,
+ * some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
+ * input elements have one current mode, which may determine the final action
+ * being triggered.
+ *
+ * Pad devices often divide buttons and sensors into groups. All elements
+ * in a group share the same current mode, but different groups may have
+ * different modes. See {@link Gdk.DevicePad.get_n_groups} and
+ * {@link Gdk.DevicePad.get_group_n_modes}.
+ *
+ * Each of the actions that a given button/strip/ring performs for a given mode
+ * is defined by a {@link Gtk.PadActionEntry}. It contains an action name that
+ * will be looked up in the given {@link Gio.ActionGroup} and activated whenever
+ * the specified input element and mode are triggered.
+ *
+ * A simple example of `GtkPadController` usage: Assigning button 1 in all
+ * modes and pad devices to an "invert-selection" action:
+ *
+ * ```c
+ * GtkPadActionEntry *pad_actions[] = {
+ *   { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
+ *   …
+ * };
+ *
+ * …
+ * action_group = g_simple_action_group_new ();
+ * action = g_simple_action_new ("pad-actions.invert-selection", NULL);
+ * g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
+ * g_action_map_add_action (G_ACTION_MAP (action_group), action);
+ * …
+ * pad_controller = gtk_pad_controller_new (action_group, NULL);
+ * ```
+ *
+ * The actions belonging to rings/strips/dials will be activated with a parameter
+ * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
+ * is required that those are made stateful and accepting this `GVariantType`.
+ * For rings the value is the angle of the ring position in degrees with 0
+ * facing up. For strips the value is the absolute position on the strip, normalized
+ * to the [0.0, 1.0] range.
+ * For dials the value is the relative movement of the dial, normalized so that the
+ * value 120 represents one logical scroll wheel detent in the positive direction.
+ * Devices that support high-resolution scrolling may send events with fractions of
+ * 120 to signify a smaller motion.
+ */
+export const GtkPadController = "GtkPadController";
+/**
+ * Manages keyboard shortcuts and their activation.
+ *
+ * Most common shortcuts are using this controller implicitly, e.g. by
+ * adding a mnemonic underline to a {@link Gtk.Label}, or by installing a key
+ * binding using {@link Gtk.WidgetClass.add_binding}, or by adding accelerators
+ * to global actions using {@link Gtk.Application.set_accels_for_action}.
+ *
+ * But it is possible to create your own shortcut controller, and add
+ * shortcuts to it.
+ *
+ * `GtkShortcutController` implements {@link Gio.ListModel} for querying the
+ * shortcuts that have been added to it.
+ *
+ * # GtkShortcutController as GtkBuildable
+ *
+ * `GtkShortcutController`s can be created in {@link Gtk.Builder} ui files, to set up
+ * shortcuts in the same place as the widgets.
+ *
+ * An example of a UI definition fragment with `GtkShortcutController`:
+ * ```xml
+ *   <object class='GtkButton'>
+ *     <child>
+ *       <object class='GtkShortcutController'>
+ *         <property name='scope'>managed</property>
+ *         <child>
+ *           <object class='GtkShortcut'>
+ *             <property name='trigger'>&lt;Control&gt;k</property>
+ *             <property name='action'>activate</property>
+ *           </object>
+ *         </child>
+ *       </object>
+ *     </child>
+ *   </object>
+ * ```
+ *
+ * This example creates a {@link Gtk.ActivateAction} for triggering the
+ * `activate` signal of the {@link Gtk.Button}. See {@link Gtk.ShortcutAction.parse_string}
+ * for the syntax for other kinds of {@link Gtk.ShortcutAction}. See
+ * {@link Gtk.ShortcutTrigger.parse_string} to learn more about the syntax
+ * for triggers.
+ */
+export const GtkShortcutController = "GtkShortcutController";

package/dist/host-config.d.ts

@@ -9,7 +9,9 @@ type TextInstance = Node;
 type SuspenseInstance = never;
 type HydratableInstance = never;
 type PublicInstance = Gtk.Widget | Gtk.Application;
-type HostContext = Record<string, never>;
+type HostContext = {
+    insideTextBuffer?: boolean;
+};
 type ChildSet = never;
 type TimeoutHandle = number;
 type NoTimeout = -1;

package/dist/host-config.js

@@ -1,7 +1,8 @@
-import { batch, beginBatch, endBatch, getNativeId } from "@gtkx/ffi";
+import { getNativeId } from "@gtkx/ffi";
 import React from "react";
 import { createNode } from "./factory.js";
-import { signalStore } from "./nodes/internal/signal-store.js";
+import { isBufferedType } from "./nodes/internal/predicates.js";
+import { getSignalStore } from "./nodes/internal/signal-store.js";
 import { flushAfterCommit } from "./scheduler.js";
 if (!globalThis.__GTKX_CONTAINER_NODE_CACHE__) {
     globalThis.__GTKX_CONTAINER_NODE_CACHE__ = new Map();
@@ -25,12 +26,26 @@ export function createHostConfig() {
         isPrimaryRenderer: true,
         noTimeout: -1,
         getRootHostContext: () => ({}),
-        getChildHostContext: (parentHostContext) => parentHostContext,
+        getChildHostContext: (parentHostContext, type) => {
+            if (isBufferedType(type) || type === "TextTag") {
+                return { insideTextBuffer: true };
+            }
+            if (parentHostContext.insideTextBuffer) {
+                return {};
+            }
+            return parentHostContext;
+        },
         shouldSetTextContent: () => false,
         createInstance: (type, props, rootContainer) => {
             return createNode(type, props, undefined, rootContainer);
         },
-        createTextInstance: (text, rootContainer) => {
+        createTextInstance: (text, rootContainer, hostContext) => {
+            if (hostContext.insideTextBuffer) {
+                const props = { text };
+                const node = createNode("TextSegment", props, undefined, rootContainer);
+                node.updateProps(null, props);
+                return node;
+            }
             const props = { label: text };
             const node = createNode("GtkLabel", props, undefined, rootContainer);
             node.updateProps(null, props);
@@ -40,7 +55,9 @@ export function createHostConfig() {
             parent.appendChild(child);
         },
         finalizeInitialChildren: (instance, _type, props) => {
+            instance.signalStore.blockAll();
             instance.updateProps(null, props);
+            instance.signalStore.unblockAll();
             return true;
         },
         commitUpdate: (instance, _type, oldProps, newProps) => {
@@ -70,18 +87,21 @@ export function createHostConfig() {
             const parent = getOrCreateContainerNode(container);
             parent.insertBefore(child, beforeChild);
         },
-        prepareForCommit: () => {
-            beginBatch();
+        prepareForCommit: (containerInfo) => {
+            getSignalStore(containerInfo).blockAll();
             return null;
         },
-        resetAfterCommit: () => {
-            batch(() => signalStore.blockAll());
-            endBatch();
+        resetAfterCommit: (containerInfo) => {
             flushAfterCommit();
-            signalStore.unblockAll();
+            getSignalStore(containerInfo).unblockAll();
         },
         commitTextUpdate: (textInstance, oldText, newText) => {
-            textInstance.updateProps({ label: oldText }, { label: newText });
+            if (textInstance.typeName === "TextSegment") {
+                textInstance.updateProps({ text: oldText }, { text: newText });
+            }
+            else {
+                textInstance.updateProps({ label: oldText }, { label: newText });
+            }
         },
         clearContainer: () => { },
         preparePortalMount: () => { },