Add cursor moving (#19)

frontend/sync-client/src/file-operations/file-operations.test.ts

@@ -6,7 +6,10 @@ import type {
 import { FileOperations } from "./file-operations";
 import { Logger } from "../tracing/logger";
 import { assertSetContainsExactly } from "../utils/assert-set-contains-exactly";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import init, { base64ToBytes } from "sync_lib";
 import fs from "fs";
 
@@ -43,7 +46,7 @@ class FakeFileSystemOperations implements FileSystemOperations {
 	}
 	public async atomicUpdateText(
 		_path: RelativePath,
-		_updater: (currentContent: string) => string
+		_updater: (current: TextWithCursors) => TextWithCursors
 	): Promise<string> {
 		throw new Error("Method not implemented.");
 	}

frontend/sync-client/src/file-operations/file-operations.ts

@@ -1,7 +1,16 @@
 import type { Logger } from "../tracing/logger";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import type { Database, RelativePath } from "../persistence/database";
-import { isBinary, isFileTypeMergable, mergeText } from "sync_lib";
+import {
+	CursorPosition,
+	isBinary,
+	isFileTypeMergable,
+	mergeTextWithCursors,
+	TextWithCursors as RustTextWithCursors
+} from "sync_lib";
 import { SafeFileSystemOperations } from "./safe-filesystem-operations";
 
 export class FileOperations {
@@ -90,18 +99,45 @@ export class FileOperations {
 		const expectedText = new TextDecoder().decode(expectedContent); // this comes from a previous read which must only have \n line endings
 		const newText = new TextDecoder().decode(newContent); // this comes from the server which stores text with \n line endings
 
-		await this.fs.atomicUpdateText(path, (currentText) => {
-			currentText = currentText.replace(this.nativeLineEndings, "\n");
+		await this.fs.atomicUpdateText(
+			path,
+			({ text, cursors }: TextWithCursors): TextWithCursors => {
+				text = text.replace(this.nativeLineEndings, "\n");
 
-			this.logger.debug(
-				`Performing a 3-way merge for ${path} with the expected content`
-			);
+				this.logger.debug(
+					`Performing a 3-way merge for ${path} with the expected content`
+				);
 
-			return mergeText(expectedText, currentText, newText).replace(
-				"\n",
-				this.nativeLineEndings
-			);
-		});
+				const left = new RustTextWithCursors(
+					text,
+					cursors.map(
+						(cursor) =>
+							new CursorPosition(
+								cursor.id,
+								cursor.characterPosition
+							)
+					)
+				);
+				const right = new RustTextWithCursors(newText, []);
+				const merged = mergeTextWithCursors(expectedText, left, right);
+
+				const resultText = merged
+					.text()
+					.replace("\n", this.nativeLineEndings);
+
+				const resultCursors = merged.cursors().map((cursor) => ({
+					id: cursor.id(),
+					characterPosition: cursor.characterPosition()
+				}));
+
+				merged.free();
+
+				return {
+					text: resultText,
+					cursors: resultCursors
+				};
+			}
+		);
 	}
 
 	public async delete(path: RelativePath): Promise<void> {

frontend/sync-client/src/file-operations/filesystem-operations.ts

@@ -1,5 +1,15 @@
 import type { RelativePath } from "../persistence/database";
 
+export interface Cursor {
+	id: number;
+	characterPosition: number;
+}
+
+export interface TextWithCursors {
+	text: string;
+	cursors: Cursor[];
+}
+
 export interface FileSystemOperations {
 	// List all files that should be synced.
 	listAllFiles: () => Promise<RelativePath[]>;
@@ -13,7 +23,7 @@ export interface FileSystemOperations {
 	// Atomically update the content of a text file.
 	atomicUpdateText: (
 		path: RelativePath,
-		updater: (currentContent: string) => string
+		updater: (current: TextWithCursors) => TextWithCursors
 	) => Promise<string>;
 
 	// Get the size of a file in bytes.

frontend/sync-client/src/file-operations/safe-filesystem-operations.ts

@@ -1,5 +1,8 @@
 import type { RelativePath } from "../persistence/database";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import type { Logger } from "../tracing/logger";
 import { Locks } from "../utils/locks";
 import { FileNotFoundError } from "./file-not-found-error";
@@ -44,7 +47,7 @@ export class SafeFileSystemOperations implements FileSystemOperations {
 
 	public async atomicUpdateText(
 		path: RelativePath,
-		updater: (currentContent: string) => string
+		updater: (current: TextWithCursors) => TextWithCursors
 	): Promise<string> {
 		this.logger.debug(`Atomically updating file '${path}'`);
 		return this.safeOperation(