jazz-tools 0.9.8 → 0.9.9

package/dist/index.native.js

@@ -26,7 +26,7 @@ import {
   loadCoValue,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-YD32FKHW.js";
+} from "./chunk-VQZOWIPU.js";
 
 // src/index.native.ts
 import {

package/dist/index.web.js

@@ -26,7 +26,7 @@ import {
   loadCoValue,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-YD32FKHW.js";
+} from "./chunk-VQZOWIPU.js";
 
 // src/index.web.ts
 import { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "cojson";

package/dist/testing.js

@@ -2,7 +2,7 @@ import {
   Account,
   activeAccountContext,
   createAnonymousJazzContext
-} from "./chunk-YD32FKHW.js";
+} from "./chunk-VQZOWIPU.js";
 
 // src/testing.ts
 import { cojsonInternals } from "cojson";

package/package.json

@@ -23,9 +23,9 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "dependencies": {
-    "cojson": "0.9.0"
+    "cojson": "0.9.9"
   },
   "devDependencies": {
     "tsup": "8.3.5",

package/src/coValues/coPlainText.ts

@@ -63,6 +63,10 @@ export class CoPlainText extends String implements CoValue {
     return new this({ text, owner: options.owner });
   }
 
+  get length() {
+    return this._raw.toString().length;
+  }
+
   toString() {
     return this._raw.toString();
   }
@@ -154,7 +158,7 @@ export class CoPlainText extends String implements CoValue {
   //   }
 
   /**
-   * Load and subscribe to a `CoMap` with a given ID, as a given account.
+   * Load and subscribe to a `CoPlainText` with a given ID, as a given account.
    *
    * Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.
    *
@@ -226,9 +230,9 @@ export class CoPlainText extends String implements CoValue {
   //   }
 
   /**
-   * Given an already loaded `CoMap`, subscribe to updates to the `CoMap` and ensure that the specified fields are loaded to the specified depth.
+   * Given an already loaded `CoPlainText`, subscribe to updates to the `CoPlainText` and ensure that the specified fields are loaded to the specified depth.
    *
-   * Works like `CoMap.subscribe()`, but you don't need to pass the ID or the account to load as again.
+   * Works like `CoPlainText.subscribe()`, but you don't need to pass the ID or the account to load as again.
    *
    * Returns an unsubscribe function that you should call when you no longer need updates.
    *

package/src/coValues/coRichText.ts

@@ -8,6 +8,33 @@ import type { Group } from "./group.js";
 /**
  * Base class for text annotations and formatting marks.
  * Represents a mark with start and end positions in text.
+ *
+ * Example text: "Hello world! How are you?"
+ * If we want to mark "world" with bold:
+ *
+ * ```
+ *            uncertainty region
+ *                   ↓
+ * Hello [····]world[····]! How are you?
+ *       ↑    ↑     ↑    ↑
+ *       |    |     |    |
+ * startAfter |     |  endBefore
+ *  startBefore     endAfter
+ * ```
+ *
+ * - startAfter: Position after "Hello " (exclusive boundary)
+ * - startBefore: Position before "world" (inclusive boundary)
+ * - endAfter: Position after "world" (inclusive boundary)
+ * - endBefore: Position before "!" (exclusive boundary)
+ *
+ * The regions marked with [····] are "uncertainty regions" where:
+ * - Text inserted in the left uncertainty region may or may not be part of the mark
+ * - Text inserted in the right uncertainty region may or may not be part of the mark
+ * - Text inserted between startBefore and endAfter is definitely part of the mark
+ *
+ * Positions must satisfy:
+ * 0 ≤ startAfter ≤ startBefore < endAfter ≤ endBefore ≤ textLength
+ * A mark cannot be zero-length, so endAfter must be greater than startBefore.
  */
 export class Mark extends CoMap {
   startAfter = co.json<TextPos | null>();
@@ -15,6 +42,41 @@ export class Mark extends CoMap {
   endAfter = co.json<TextPos>();
   endBefore = co.json<TextPos | null>();
   tag = co.string;
+
+  /**
+   * Validates and clamps mark positions to ensure they are in the correct order
+   * @returns Normalized positions or null if invalid
+   */
+  validatePositions(
+    textLength: number,
+    idxAfter: (pos: TextPos) => number | undefined,
+    idxBefore: (pos: TextPos) => number | undefined,
+  ) {
+    if (!textLength) {
+      console.error("Cannot validate positions for empty text");
+      return null;
+    }
+
+    // Get positions with fallbacks
+    const positions = {
+      startAfter: this.startAfter ? (idxBefore(this.startAfter) ?? 0) : 0,
+      startBefore: this.startBefore ? (idxAfter(this.startBefore) ?? 0) : 0,
+      endAfter: this.endAfter
+        ? (idxBefore(this.endAfter) ?? textLength)
+        : textLength,
+      endBefore: this.endBefore
+        ? (idxAfter(this.endBefore) ?? textLength)
+        : textLength,
+    };
+
+    // Clamp and ensure proper ordering in one step
+    return {
+      startAfter: Math.max(0, positions.startAfter),
+      startBefore: Math.max(positions.startAfter + 1, positions.startBefore),
+      endAfter: Math.min(textLength - 1, positions.endAfter),
+      endBefore: Math.min(textLength, positions.endBefore),
+    };
+  }
 }
 
 /**
@@ -194,9 +256,21 @@ export class CoRichText extends CoMap {
     >,
     options?: { markOwner?: Account | Group },
   ) {
-    if (!this.marks) {
+    if (!this.text || !this.marks) {
       throw new Error("Cannot insert a range without loaded ranges");
     }
+
+    const textLength = this.length;
+
+    // Clamp positions to text bounds
+    start = Math.max(start, 0);
+    end = Math.min(end, textLength);
+
+    const owner = options?.markOwner || this._owner;
+    if (!owner) {
+      throw new Error("No owner specified for mark");
+    }
+
     const range = RangeClass.create(
       {
         ...extraArgs,
@@ -205,11 +279,109 @@ export class CoRichText extends CoMap {
         endAfter: this.posBefore(end),
         endBefore: this.posAfter(end),
       },
-      { owner: options?.markOwner || this._owner },
+      { owner },
     );
+
     this.marks.push(range);
   }
 
+  /**
+   * Remove a mark at a specific range.
+   */
+  removeMark<
+    MarkClass extends {
+      new (...args: any[]): Mark;
+      create(init: any, options: { owner: Account | Group }): Mark;
+    },
+  >(
+    start: number,
+    end: number,
+    RangeClass: MarkClass,
+    options: { tag: string },
+  ) {
+    if (!this.marks) {
+      throw new Error("Cannot remove marks without loaded marks");
+    }
+
+    // Find marks of the given class that overlap with the range
+    const resolvedMarks = this.resolveMarks();
+
+    for (const mark of resolvedMarks) {
+      // If mark is outside the range, we'll skip it
+      if (mark.endBefore < start || mark.startAfter > end) {
+        continue;
+      }
+
+      // If mark is wrong type, we'll skip it
+      if (options.tag && mark.sourceMark.tag !== options.tag) {
+        continue;
+      }
+
+      const markIndex = this.marks.findIndex((m) => m === mark.sourceMark);
+      if (markIndex === -1) {
+        continue;
+      }
+
+      // If mark is completely inside the range, we'll remove it
+      if (mark.startBefore >= start && mark.endAfter <= end) {
+        // Remove the mark
+        this.marks.splice(markIndex, 1);
+        continue;
+      }
+
+      // If mark starts before and extends after the removal range, update end positions to start of removal
+      if (
+        mark.startBefore < start &&
+        mark.endAfter >= start &&
+        mark.endAfter <= end
+      ) {
+        const endAfterPos = this.posBefore(start);
+        const endBeforePos = this.posBefore(start);
+        if (endAfterPos && endBeforePos) {
+          mark.sourceMark.endAfter = endAfterPos;
+          mark.sourceMark.endBefore = endBeforePos;
+        }
+        continue;
+      }
+
+      // If mark starts in removal range and extends beyond it, update start positions to end of removal
+      if (
+        mark.startBefore >= start &&
+        mark.startBefore <= end &&
+        mark.endAfter > end
+      ) {
+        const startAfterPos = this.posAfter(end);
+        const startBeforePos = this.posAfter(end);
+        if (startAfterPos && startBeforePos) {
+          mark.sourceMark.startAfter = startAfterPos;
+          mark.sourceMark.startBefore = startBeforePos;
+        }
+        continue;
+      }
+
+      // If removal is inside the mark, we'll split the mark
+      if (mark.startBefore <= start && mark.endAfter >= end) {
+        // Split the mark by shortening it at the start and adding a new mark at the end
+        const endAfterPos = this.posBefore(start);
+        const endBeforePos = this.posBefore(start);
+        if (endAfterPos && endBeforePos) {
+          mark.sourceMark.endAfter = endAfterPos;
+          mark.sourceMark.endBefore = endBeforePos;
+        }
+        this.insertMark(
+          end + 1,
+          mark.endBefore,
+          RangeClass,
+          {},
+          {
+            markOwner: mark.sourceMark._owner || this._owner,
+          },
+        );
+        continue;
+      }
+    }
+  }
+
   /**
    * Resolve the positions of all marks.
    */
@@ -217,35 +389,27 @@ export class CoRichText extends CoMap {
     if (!this.text || !this.marks) {
       throw new Error("Cannot resolve ranges without loaded text and ranges");
     }
-    const ranges = this.marks.flatMap((mark) => {
+
+    const textLength = this.length;
+
+    return this.marks.flatMap((mark) => {
       if (!mark) return [];
-      const startBefore = this.idxAfter(mark.startBefore);
-      const endAfter = this.idxAfter(mark.endAfter);
-      if (startBefore === undefined || endAfter === undefined) {
-        return [];
-      }
-      const startAfter = mark.startAfter
-        ? this.idxAfter(mark.startAfter)
-        : startBefore - 1;
-      const endBefore = mark.endBefore
-        ? this.idxAfter(mark.endBefore)
-        : endAfter + 1;
-      if (startAfter === undefined || endBefore === undefined) {
-        return [];
-      }
+
+      const positions = mark.validatePositions(
+        textLength,
+        (pos) => this.idxAfter(pos),
+        (pos) => this.idxBefore(pos),
+      );
+      if (!positions) return [];
+
       return [
         {
           sourceMark: mark,
-          startAfter,
-          startBefore,
-          endAfter,
-          endBefore,
+          ...positions,
           tag: mark.tag,
-          from: mark,
         },
       ];
     });
-    return ranges;
   }
 
   /**
@@ -298,10 +462,10 @@ export class CoRichText extends CoMap {
   toTree(tagPrecedence: string[]): TreeNode {
     const ranges = this.resolveAndDiffuseAndFocusMarks();
 
-    // convert a bunch of (potentially overlapping) ranges into a tree
+    // Convert a bunch of (potentially overlapping) ranges into a tree
     // - make sure we include all text in leaves, even if it's not covered by a range
     // - we split overlapping ranges in a way where the higher precedence (tag earlier in tagPrecedence)
-    // stays intact and the lower precende tag is split into two ranges, one inside and one outside the higher precedence range
+    // stays intact and the lower precedence tag is split into two ranges, one inside and one outside the higher precedence range
 
     const text = this.text?.toString() || "";
 
@@ -328,14 +492,6 @@ export class CoRichText extends CoMap {
           ? splitNode(inOrAfter, range.end)
           : [undefined, undefined];
 
-        // console.log("split", range.start, range.end, {
-        //     before,
-        //     inside,
-        //     after,
-        // });
-
-        // TODO: also split children
-
         return [
           ...(before ? [before] : []),
           ...(inside
@@ -365,6 +521,10 @@ export class CoRichText extends CoMap {
     };
   }
 
+  get length() {
+    return this.text?.toString().length || 0;
+  }
+
   /**
    * Convert a CoRichText to plain text.
    */
@@ -400,7 +560,7 @@ export type TreeNode = {
 /**
  * Split a node at a specific index. So that the node is split into two parts, one before the index, and one after the index.
  */
-function splitNode(
+export function splitNode(
   node: TreeNode | TreeLeaf,
   at: number,
 ): [TreeNode | TreeLeaf | undefined, TreeNode | TreeLeaf | undefined] {

package/src/exports.ts

@@ -33,6 +33,7 @@ export {
   Marks,
   type TreeLeaf,
   type TreeNode,
+  type ResolvedMark,
 } from "./coValues/coRichText.js";
 export { ImageDefinition } from "./coValues/extensions/imageDef.js";
 export { Group } from "./coValues/group.js";

package/src/internal.ts

@@ -1,13 +1,13 @@
-export * from "./implementation/symbols.js";
-export * from "./implementation/inspect.js";
 export * from "./coValues/interfaces.js";
+export * from "./implementation/inspect.js";
+export * from "./implementation/symbols.js";
 
-export * from "./implementation/errors.js";
+export * from "./coValues/deepLoading.js";
 export * from "./implementation/anonymousJazzAgent.js";
+export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
-export * from "./coValues/deepLoading.js";
 
 export * from "./implementation/createContext.js";
 

package/src/tests/coPlainText.test.ts

@@ -1,33 +1,161 @@
+import { connectedPeers } from "cojson/src/streamUtils.js";
 import { describe, expect, test } from "vitest";
-import { Account, CoPlainText, WasmCrypto } from "../index.web.js";
+import {
+  Account,
+  CoPlainText,
+  WasmCrypto,
+  cojsonInternals,
+  createJazzContext,
+  fixedCredentialsAuth,
+  isControlledAccount,
+} from "../index.web.js";
+import { randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
-describe("Simple CoPlainText operations", async () => {
-  const me = await Account.create({
-    creationProps: { name: "Hermes Puggington" },
-    crypto: Crypto,
+describe("CoPlainText", () => {
+  const initNodeAndText = async () => {
+    const me = await Account.create({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
+    });
+
+    const text = CoPlainText.create("hello world", { owner: me });
+
+    return { me, text };
+  };
+
+  describe("Simple CoPlainText operations", async () => {
+    const { me, text } = await initNodeAndText();
+
+    test("Construction", () => {
+      expect(text + "").toEqual("hello world");
+    });
+
+    describe("Mutation", () => {
+      test("insertion", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        text.insertAfter(5, " cruel");
+        expect(text + "").toEqual("hello cruel world");
+
+        text.insertAfter(0, "Hello, ");
+        expect(text + "").toEqual("Hello, hello cruel world");
+      });
+
+      test("deletion", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        text.deleteRange({ from: 3, to: 8 });
+        expect(text + "").toEqual("helrld");
+      });
+    });
+
+    describe("Position operations", () => {
+      test("idxBefore returns index before a position", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        // Get position at index 5 (between "hello" and " world")
+        const pos = text.posBefore(5);
+        expect(pos).toBeDefined();
+
+        // Verify idxBefore returns the index before the position (4)
+        // This makes sense as the position is between characters,
+        // and idxBefore returns the index of the last character before that position
+        const idx = text.idxBefore(pos!);
+        expect(idx).toBe(4); // Index of 'o' in "hello"
+      });
+
+      test("idxAfter returns index after a position", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        // Get position at index 5 (between "hello" and " world")
+        const pos = text.posBefore(5);
+        expect(pos).toBeDefined();
+
+        // Verify idxAfter returns the index after the position (5)
+        // This makes sense as the position is between characters,
+        // and idxAfter returns the index of the first character after that position
+        const idx = text.idxAfter(pos!);
+        expect(idx).toBe(5); // Index of ' ' in "hello world"
+      });
+    });
   });
 
-  const text = CoPlainText.create("hello world", { owner: me });
+  describe("Loading and availability", () => {
+    test("can load text across peers", async () => {
+      const { me, text } = await initNodeAndText();
+      const id = text.id;
+
+      // Set up peer connections
+      const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+        peer1role: "server",
+        peer2role: "client",
+      });
+
+      if (!isControlledAccount(me)) {
+        throw "me is not a controlled account";
+      }
+      me._raw.core.node.syncManager.addPeer(secondPeer);
+      const { account: meOnSecondPeer } = await createJazzContext({
+        auth: fixedCredentialsAuth({
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        }),
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
-  test("Construction", () => {
-    expect(text + "").toEqual("hello world");
+      // Load the text on the second peer
+      const loaded = await CoPlainText.load(id, meOnSecondPeer);
+      expect(loaded).toBeDefined();
+      expect(loaded!.toString()).toBe("hello world");
+    });
   });
 
-  describe("Mutation", () => {
-    test("insertion", () => {
-      const text = CoPlainText.create("hello world", { owner: me });
+  test("Subscription & auto-resolution", async () => {
+    const { me, text } = await initNodeAndText();
+
+    // Set up peer connections
+    const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+      peer1role: "server",
+      peer2role: "client",
+    });
 
-      text.insertAfter(5, " cruel");
-      expect(text + "").toEqual("hello cruel world");
+    if (!isControlledAccount(me)) {
+      throw "me is not a controlled account";
+    }
+    me._raw.core.node.syncManager.addPeer(secondPeer);
+    const { account: meOnSecondPeer } = await createJazzContext({
+      auth: fixedCredentialsAuth({
+        accountID: me.id,
+        secret: me._raw.agentSecret,
+      }),
+      sessionProvider: randomSessionProvider,
+      peersToLoadFrom: [initialAsPeer],
+      crypto: Crypto,
     });
 
-    test("deletion", () => {
-      const text = CoPlainText.create("hello world", { owner: me });
+    const queue = new cojsonInternals.Channel();
 
-      text.deleteRange({ from: 3, to: 8 });
-      expect(text + "").toEqual("helrld");
+    // Subscribe to text updates
+    CoPlainText.subscribe(text.id, meOnSecondPeer, (subscribedText) => {
+      void queue.push(subscribedText);
     });
+
+    // Initial subscription should give us the text
+    const update1 = (await queue.next()).value;
+    expect(update1.toString()).toBe("hello world");
+
+    // When we make a change, we should get an update
+    text.insertAfter(5, " beautiful");
+    const update2 = (await queue.next()).value;
+    expect(update2.toString()).toBe("hello beautiful world");
+
+    // When we make another change, we should get another update
+    update2.deleteRange({ from: 5, to: 15 }); // Delete " beautiful"
+    const update3 = (await queue.next()).value;
+    expect(update3.toString()).toBe("hello world");
   });
 });