@copilotkit/react-textarea 1.81.0 → 1.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/react-textarea",
-  "version": "1.81.0",
+  "version": "1.82.0",
   "private": false,
   "keywords": [
     "ai",
@@ -59,9 +59,9 @@
     "slate-history": "^0.93.0",
     "slate-react": "^0.98.1",
     "tailwind-merge": "^1.13.2",
-    "@copilotkit/react-core": "1.81.0",
-    "@copilotkit/shared": "1.81.0",
-    "@copilotkit/runtime-client-gql": "1.81.0"
+    "@copilotkit/runtime-client-gql": "1.82.0",
+    "@copilotkit/react-core": "1.82.0",
+    "@copilotkit/shared": "1.82.0"
   },
   "devDependencies": {
     "@types/lodash.merge": "^4.6.7",

package/src/lib/editor-to-text.test.ts

@@ -0,0 +1,60 @@
+import type { Descendant } from "slate";
+import { createEditor } from "slate";
+import { editorToText } from "./editor-to-text";
+import { getFullEditorTextWithNewlines } from "./get-text-around-cursor";
+
+const editorWith = (children: any[]) => {
+  const editor = createEditor();
+  editor.children = children as Descendant[];
+  return editor;
+};
+
+describe("editorToText", () => {
+  it("does not insert newlines between text nodes inside one block", () => {
+    const editor = editorWith([
+      {
+        type: "paragraph",
+        children: [
+          { text: "Hello " },
+          {
+            type: "suggestion",
+            inline: true,
+            content: "SUGGESTED",
+            children: [{ text: "" }],
+          },
+          { text: "world" },
+        ],
+      },
+    ]);
+
+    expect(editorToText(editor)).toBe("Hello world");
+  });
+
+  it("agrees with getFullEditorTextWithNewlines on a split block", () => {
+    const editor = editorWith([
+      {
+        type: "paragraph",
+        children: [{ text: "Hello " }, { text: "world" }],
+      },
+    ]);
+
+    expect(editorToText(editor)).toBe(getFullEditorTextWithNewlines(editor));
+  });
+
+  it("still separates blocks with a newline", () => {
+    const editor = editorWith([
+      { type: "paragraph", children: [{ text: "one" }] },
+      { type: "paragraph", children: [{ text: "two" }] },
+    ]);
+
+    expect(editorToText(editor)).toBe("one\ntwo");
+  });
+
+  it("reads a single unsplit block unchanged", () => {
+    const editor = editorWith([
+      { type: "paragraph", children: [{ text: "Hello world" }] },
+    ]);
+
+    expect(editorToText(editor)).toBe("Hello world");
+  });
+});

package/src/lib/editor-to-text.ts

@@ -1,7 +1,8 @@
-import { BaseEditor, Descendant, Element } from "slate";
-import { HistoryEditor } from "slate-history";
-import { ReactEditor } from "slate-react";
-import { SuggestionAwareText } from "../types/base/custom-editor";
+import type { BaseEditor, Descendant } from "slate";
+import { Element } from "slate";
+import type { HistoryEditor } from "slate-history";
+import type { ReactEditor } from "slate-react";
+import type { SuggestionAwareText } from "../types/base/custom-editor";
 
 function nodeChildrenToTextComponents(
   editor: BaseEditor & ReactEditor & HistoryEditor,
@@ -56,9 +57,16 @@ function nodeChildrenToTextComponents(
 export const editorToText = (
   editor: BaseEditor & ReactEditor & HistoryEditor,
 ) => {
-  const flattened = nodeChildrenToTextComponents(editor, editor.children);
-
-  const text = flattened.map((textComponent) => textComponent.text).join("\n");
-
-  return text;
+  // Join blocks with a newline, but never join the text nodes *inside* a block
+  // with one: Slate splits a single paragraph's text into several nodes whenever
+  // an inline void (a suggestion) or a leaf mark (bold) sits in the middle, and
+  // joining those with "\n" injected a phantom line break that the sibling
+  // `getFullEditorTextWithNewlines` does not produce for the same document.
+  return editor.children
+    .map((node) =>
+      nodeChildrenToTextComponents(editor, [node])
+        .map((textComponent) => textComponent.text)
+        .join(""),
+    )
+    .join("\n");
 };

package/src/lib/slatejs-edits/replace-text.test.ts

@@ -0,0 +1,56 @@
+import { createEditor, Editor, Transforms } from "slate";
+import { replaceEditorText } from "./replace-text";
+import { getFullEditorTextWithNewlines } from "../get-text-around-cursor";
+
+const seedEditor = () => {
+  const editor = createEditor();
+  editor.children = [
+    { type: "paragraph", children: [{ text: "seed" }] } as any,
+  ];
+  Transforms.select(editor, { path: [0, 0], offset: 4 });
+  return editor;
+};
+
+describe("replaceEditorText", () => {
+  it("fills the cleared block instead of adding a second one", () => {
+    const editor = seedEditor();
+
+    replaceEditorText(editor, "hello");
+
+    expect(editor.children).toHaveLength(1);
+    expect(getFullEditorTextWithNewlines(editor)).toBe("hello");
+  });
+
+  it("round-trips the exact value it was given", () => {
+    const editor = seedEditor();
+
+    replaceEditorText(editor, "hello");
+    expect(getFullEditorTextWithNewlines(editor)).toBe("hello");
+
+    replaceEditorText(editor, "goodbye");
+    expect(editor.children).toHaveLength(1);
+    expect(getFullEditorTextWithNewlines(editor)).toBe("goodbye");
+  });
+
+  it("replaces a multi-block document with a single block", () => {
+    const editor = createEditor();
+    editor.children = [
+      { type: "paragraph", children: [{ text: "one" }] } as any,
+      { type: "paragraph", children: [{ text: "two" }] } as any,
+    ];
+    Transforms.select(editor, Editor.end(editor, []));
+
+    replaceEditorText(editor, "fresh");
+
+    expect(editor.children).toHaveLength(1);
+    expect(getFullEditorTextWithNewlines(editor)).toBe("fresh");
+  });
+
+  it("still leaves the document empty when given an empty string", () => {
+    const editor = seedEditor();
+
+    replaceEditorText(editor, "");
+
+    expect(getFullEditorTextWithNewlines(editor)).toBe("");
+  });
+});

package/src/lib/slatejs-edits/replace-text.ts

@@ -11,18 +11,13 @@ export function replaceEditorText(editor: Editor, newText: string) {
 
   // insert new text
   if (newText && newText !== "") {
-    // don't insert empty text - results in strange visual behavior
-    Transforms.insertNodes(
-      editor,
-      [
-        {
-          type: "paragraph",
-          children: [{ text: newText }],
-        },
-      ],
-      {
-        at: [0],
-      },
-    );
+    // Don't insert empty text - results in strange visual behavior.
+    // Insert into the empty block the delete above left behind rather than
+    // adding a new one: `insertNodes` at [0] would prepend a second block and
+    // leave a trailing empty paragraph, so the text would read back with a
+    // trailing newline and grow on every call.
+    Transforms.insertText(editor, newText, {
+      at: Editor.start(editor, []),
+    });
   }
 }