cojson 0.13.7 → 0.13.11

package/src/coValues/coList.ts

@@ -2,6 +2,7 @@ import { CoID, RawCoValue } from "../coValue.js";
 import { CoValueCore } from "../coValueCore.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
+import { CoValueKnownState } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";
@@ -81,6 +82,8 @@ export class RawCoListView<
     madeAt: number;
     opID: OpID;
   }[];
+  /** @internal */
+  knownTransactions: CoValueKnownState["sessions"];
 
   /** @internal */
   constructor(core: CoValueCore) {
@@ -95,12 +98,24 @@ export class RawCoListView<
     this.deletionsByInsertion = {};
     this.afterStart = [];
     this.beforeEnd = [];
+    this.knownTransactions = {};
+
+    this.processNewTransactions();
+  }
+
+  processNewTransactions() {
+    const newTransactions = this.core.getValidTransactions({
+      ignorePrivateTransactions: false,
+      knownTransactions: this.knownTransactions,
+    });
 
-    for (const {
-      txID,
-      changes,
-      madeAt,
-    } of this.core.getValidSortedTransactions()) {
+    if (newTransactions.length === 0) {
+      return;
+    }
+
+    this._cachedEntries = undefined;
+
+    for (const { txID, changes, madeAt } of newTransactions) {
       for (const [changeIdx, changeUntyped] of changes.entries()) {
         const change = changeUntyped as ListOpPayload<Item>;
 
@@ -192,6 +207,11 @@ export class RawCoListView<
           );
         }
       }
+
+      this.knownTransactions[txID.sessionID] = Math.max(
+        this.knownTransactions[txID.sessionID] ?? 0,
+        txID.txIndex,
+      );
     }
   }
 
@@ -279,30 +299,52 @@ export class RawCoListView<
       opID: OpID;
     }[],
   ) {
-    const entry =
-      this.insertions[opID.sessionID]?.[opID.txIndex]?.[opID.changeIdx];
+    const todo = [opID]; // a stack with the next item to do at the end
+    const predecessorsVisited = new Set<OpID>();
 
-    if (!entry) {
-      throw new Error("Missing op " + opID);
-    }
-    for (const predecessor of entry.predecessors) {
-      this.fillArrayFromOpID(predecessor, arr);
-    }
-    const deleted =
-      (this.deletionsByInsertion[opID.sessionID]?.[opID.txIndex]?.[
-        opID.changeIdx
-      ]?.length || 0) > 0;
-    if (!deleted) {
-      arr.push({
-        value: entry.value,
-        madeAt: entry.madeAt,
-        opID,
-      });
-    }
-    // traverse successors in reverse for correct insertion behavior
-    for (let i = entry.successors.length - 1; i >= 0; i--) {
-      const successor = entry.successors[i]!;
-      this.fillArrayFromOpID(successor, arr);
+    while (todo.length > 0) {
+      const currentOpID = todo[todo.length - 1]!;
+
+      const entry =
+        this.insertions[currentOpID.sessionID]?.[currentOpID.txIndex]?.[
+          currentOpID.changeIdx
+        ];
+
+      if (!entry) {
+        throw new Error("Missing op " + currentOpID);
+      }
+
+      const shouldTraversePredecessors =
+        entry.predecessors.length > 0 && !predecessorsVisited.has(currentOpID);
+
+      // We navigate the predecessors before processing the current opID in the list
+      if (shouldTraversePredecessors) {
+        for (let i = entry.predecessors.length - 1; i >= 0; i--) {
+          todo.push(entry.predecessors[i]!);
+        }
+        predecessorsVisited.add(currentOpID);
+      } else {
+        // Remove the current opID from the todo stack to consider it processed.
+        todo.pop();
+
+        const deleted =
+          (this.deletionsByInsertion[currentOpID.sessionID]?.[
+            currentOpID.txIndex
+          ]?.[currentOpID.changeIdx]?.length || 0) > 0;
+
+        if (!deleted) {
+          arr.push({
+            value: entry.value,
+            madeAt: entry.madeAt,
+            opID: currentOpID,
+          });
+        }
+
+        // traverse successors in reverse for correct insertion behavior
+        for (const successor of entry.successors) {
+          todo.push(successor);
+        }
+      }
     }
   }
 
@@ -410,6 +452,15 @@ export class RawCoList<
     this.appendItems([item], after, privacy);
   }
 
+  /**
+   * Appends `items` to the list at index `after`. If `after` is negative, it is treated as `0`.
+   *
+   * If `privacy` is `"private"` **(default)**, `items` are encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+   *
+   * If `privacy` is `"trusting"`, `items` are stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+   *
+   * @category 2. Editing
+   */
   appendItems(
     items: Item[],
     after?: number,
@@ -421,7 +472,7 @@ export class RawCoList<
         ? entries.length > 0
           ? entries.length - 1
           : 0
-        : after;
+        : Math.max(0, after);
     let opIDBefore: OpID | "start";
     if (entries.length > 0) {
       const entryBefore = entries[after];
@@ -450,7 +501,7 @@ export class RawCoList<
 
     this.core.makeTransaction(changes, privacy);
 
-    this.rebuildFromCore();
+    this.processNewTransactions();
   }
 
   /**
@@ -497,7 +548,7 @@ export class RawCoList<
       privacy,
     );
 
-    this.rebuildFromCore();
+    this.processNewTransactions();
   }
 
   /** Deletes the item at index `at`.
@@ -524,7 +575,7 @@ export class RawCoList<
       privacy,
     );
 
-    this.rebuildFromCore();
+    this.processNewTransactions();
   }
 
   replace(
@@ -552,17 +603,6 @@ export class RawCoList<
       ],
       privacy,
     );
-    this.rebuildFromCore();
-  }
-
-  /** @internal */
-  rebuildFromCore() {
-    const listAfter = new RawCoList(this.core) as this;
-
-    this.afterStart = listAfter.afterStart;
-    this.beforeEnd = listAfter.beforeEnd;
-    this.insertions = listAfter.insertions;
-    this.deletionsByInsertion = listAfter.deletionsByInsertion;
-    this._cachedEntries = undefined;
+    this.processNewTransactions();
   }
 }

package/src/coValues/coPlainText.ts

@@ -2,6 +2,12 @@ import { CoValueCore } from "../coValueCore.js";
 import { JsonObject } from "../jsonValue.js";
 import { DeletionOpPayload, OpID, RawCoList } from "./coList.js";
 
+declare const navigator:
+  | {
+      language: string;
+    }
+  | undefined;
+
 export type StringifiedOpID = string & { __stringifiedOpID: true };
 
 export function stringifyOpID(opID: OpID): StringifiedOpID {
@@ -15,6 +21,33 @@ type PlaintextIdxMapping = {
   idxBeforeOpID: { [opID: StringifiedOpID]: number };
 };
 
+/**
+ * A collaborative plain text implementation that supports grapheme-accurate editing.
+ *
+ * Locale support:
+ * - Locale can be specified in the meta field when creating the text: `{ meta: { locale: "ja-JP" } }`
+ * - If no locale is specified, falls back to browser's locale (`navigator.language`)
+ * - If browser locale is not available, defaults to 'en'
+ *
+ * @example
+ * ```typescript
+ * // With specific locale
+ * const textJa = node.createCoValue({
+ *   type: "coplaintext",
+ *   ruleset: { type: "unsafeAllowAll" },
+ *   meta: { locale: "ja-JP" },
+ *   ...Crypto.createdNowUnique(),
+ * });
+ *
+ * // Using browser locale
+ * const text = node.createCoValue({
+ *   type: "coplaintext",
+ *   ruleset: { type: "unsafeAllowAll" },
+ *   meta: null,
+ *   ...Crypto.createdNowUnique(),
+ * });
+ * ```
+ */
 export class RawCoPlainText<
   Meta extends JsonObject | null = JsonObject | null,
 > extends RawCoList<string, Meta> {
@@ -36,7 +69,17 @@ export class RawCoPlainText<
         "Intl.Segmenter is not supported. Use a polyfill to get coPlainText support in Jazz. (eg. https://formatjs.github.io/docs/polyfills/intl-segmenter/)",
       );
     }
-    this._segmenter = new Intl.Segmenter("en", {
+
+    // Use locale from meta if provided, fallback to browser locale, or 'en' as last resort
+    const effectiveLocale =
+      (core.header.meta &&
+      typeof core.header.meta === "object" &&
+      "locale" in core.header.meta
+        ? (core.header.meta.locale as string)
+        : undefined) ||
+      (typeof navigator !== "undefined" ? navigator.language : "en");
+
+    this._segmenter = new Intl.Segmenter(effectiveLocale, {
       granularity: "grapheme",
     });
   }
@@ -78,7 +121,16 @@ export class RawCoPlainText<
       .join("");
   }
 
-  insertAfter(
+  /**
+   * Inserts `text` before the character at index `idx`.
+   * If idx is 0, inserts at the start of the text.
+   *
+   * @param idx - The index of the character to insert before
+   * @param text - The text to insert
+   * @param privacy - Whether the operation should be private or trusting
+   * @category 2. Editing
+   */
+  insertBefore(
     idx: number,
     text: string,
     privacy: "private" | "trusting" = "private",
@@ -86,21 +138,33 @@ export class RawCoPlainText<
     const graphemes = [...this._segmenter.segment(text)].map((g) => g.segment);
 
     if (idx === 0) {
-      // For insertions at start, just prepend each character, in reverse
+      // For insertions at start, prepend each character in reverse
       for (const grapheme of graphemes.reverse()) {
         this.prepend(grapheme, 0, privacy);
       }
     } else {
-      // For other insertions, use append after the specified index
-      // We append in forward order to maintain the text order
-      let after = idx - 1;
-      for (const grapheme of graphemes) {
-        this.append(grapheme, after, privacy);
-        after++; // Move the insertion point forward for each grapheme
-      }
+      // For other insertions, append after the previous character
+      this.appendItems(graphemes, idx - 1, privacy);
     }
   }
 
+  /**
+   * Inserts `text` after the character at index `idx`.
+   *
+   * @param idx - The index of the character to insert after
+   * @param text - The text to insert
+   * @param privacy - Whether the operation should be private or trusting
+   * @category 2. Editing
+   */
+  insertAfter(
+    idx: number,
+    text: string,
+    privacy: "private" | "trusting" = "private",
+  ) {
+    const graphemes = [...this._segmenter.segment(text)].map((g) => g.segment);
+    this.appendItems(graphemes, idx, privacy);
+  }
+
   deleteRange(
     { from, to }: { from: number; to: number },
     privacy: "private" | "trusting" = "private",
@@ -123,6 +187,6 @@ export class RawCoPlainText<
     }
     this.core.makeTransaction(ops, privacy);
 
-    this.rebuildFromCore();
+    this.processNewTransactions();
   }
 }

package/src/sync.ts

@@ -223,11 +223,7 @@ export class SyncManager {
       }
 
       peer.toldKnownState.add(id);
-      peer.optimisticKnownStates.dispatch({
-        type: "COMBINE_WITH",
-        id: id,
-        value: coValue.knownState(),
-      });
+      peer.combineOptimisticWith(id, coValue.knownState());
     } else if (!peer.toldKnownState.has(id)) {
       this.trySendToPeer(peer, {
         action: "known",
@@ -285,10 +281,7 @@ export class SyncManager {
 
       // Fill the missing known states with empty known states
       if (!peer.optimisticKnownStates.has(entry.id)) {
-        peer.optimisticKnownStates.dispatch({
-          type: "SET_AS_EMPTY",
-          id: entry.id,
-        });
+        peer.setOptimisticKnownState(entry.id, "empty");
       }
     }
 
@@ -403,11 +396,7 @@ export class SyncManager {
      * This way we can track part of the data loss that may occur when the other peer is restarted
      *
      */
-    peer.dispatchToKnownStates({
-      type: "SET",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.setKnownState(msg.id, knownStateIn(msg));
     const entry = this.local.coValuesStore.get(msg.id);
 
     if (entry.state.type === "unknown" || entry.state.type === "unavailable") {
@@ -482,11 +471,7 @@ export class SyncManager {
   async handleKnownState(msg: KnownStateMessage, peer: PeerState) {
     const entry = this.local.coValuesStore.get(msg.id);
 
-    peer.dispatchToKnownStates({
-      type: "COMBINE_WITH",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.combineWith(msg.id, knownStateIn(msg));
 
     // The header is a boolean value that tells us if the other peer do have information about the header.
     // If it's false in this point it means that the coValue is unavailable on the other peer.
@@ -526,22 +511,6 @@ export class SyncManager {
 
     let coValue: CoValueCore;
 
-    /**
-     * The new content might come while the coValue is loading or is not loaded yet.
-     *
-     * This might happen when we restart the server because:
-     * - The client known state assumes that the coValue is available on the server
-     * - The server might not have loaded the coValue yet because it was not requested
-     *
-     * In this case we need to load the coValue from the storage or other peers.
-     *
-     * If this load fails we send a correction request, because the client has the wrong assumption that
-     * we have the coValue while we don't.
-     */
-    if (entry.state.type !== "available" && !msg.header) {
-      await this.local.loadCoValueCore(msg.id, peer.id);
-    }
-
     if (entry.state.type !== "available") {
       if (!msg.header) {
         this.trySendToPeer(peer, {
@@ -560,11 +529,7 @@ export class SyncManager {
         return;
       }
 
-      peer.dispatchToKnownStates({
-        type: "UPDATE_HEADER",
-        id: msg.id,
-        header: true,
-      });
+      peer.updateHeader(msg.id, true);
 
       coValue = new CoValueCore(msg.header, this.local);
 
@@ -622,14 +587,12 @@ export class SyncManager {
 
       this.recordTransactionsSize(newTransactions, peer.role);
 
-      peer.dispatchToKnownStates({
-        type: "UPDATE_SESSION_COUNTER",
-        id: msg.id,
-        sessionId: sessionID,
-        value:
-          newContentForSession.after +
+      peer.updateSessionCounter(
+        msg.id,
+        sessionID,
+        newContentForSession.after +
           newContentForSession.newTransactions.length,
-      });
+      );
     }
 
     if (invalidStateAssumed) {
@@ -675,11 +638,7 @@ export class SyncManager {
   }
 
   async handleCorrection(msg: KnownStateMessage, peer: PeerState) {
-    peer.dispatchToKnownStates({
-      type: "SET",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.setKnownState(msg.id, knownStateIn(msg));
 
     return this.sendNewContentIncludingDependencies(msg.id, peer);
   }

package/src/tests/PeerKnownStates.test.ts

@@ -9,7 +9,7 @@ describe("PeerKnownStates", () => {
     const id = "test-id" as RawCoID;
     const knownState: CoValueKnownState = emptyKnownState(id);
 
-    peerKnownStates.dispatch({ type: "SET", id, value: knownState });
+    peerKnownStates.set(id, knownState);
 
     expect(peerKnownStates.get(id)).toEqual(knownState);
     expect(peerKnownStates.has(id)).toBe(true);
@@ -19,7 +19,7 @@ describe("PeerKnownStates", () => {
     const peerKnownStates = new PeerKnownStates();
     const id = "test-id" as RawCoID;
 
-    peerKnownStates.dispatch({ type: "UPDATE_HEADER", id, header: true });
+    peerKnownStates.updateHeader(id, true);
 
     const result = peerKnownStates.get(id);
     expect(result?.header).toBe(true);
@@ -30,12 +30,7 @@ describe("PeerKnownStates", () => {
     const id = "test-id" as RawCoID;
     const sessionId = "session-1" as SessionID;
 
-    peerKnownStates.dispatch({
-      type: "UPDATE_SESSION_COUNTER",
-      id,
-      sessionId,
-      value: 5,
-    });
+    peerKnownStates.updateSessionCounter(id, sessionId, 5);
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions[sessionId]).toBe(5);
@@ -55,8 +50,8 @@ describe("PeerKnownStates", () => {
       sessions: { [session2]: 10 },
     };
 
-    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
-    peerKnownStates.dispatch({ type: "COMBINE_WITH", id, value: combineState });
+    peerKnownStates.set(id, initialState);
+    peerKnownStates.combineWith(id, combineState);
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions).toEqual({ [session1]: 5, [session2]: 10 });
@@ -71,8 +66,8 @@ describe("PeerKnownStates", () => {
       sessions: { [sessionId]: 5 },
     };
 
-    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, initialState);
+    peerKnownStates.set(id, "empty");
 
     const result = peerKnownStates.get(id);
     expect(result).toEqual(emptyKnownState(id));
@@ -84,7 +79,7 @@ describe("PeerKnownStates", () => {
     const listener = vi.fn();
 
     peerKnownStates.subscribe(listener);
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, "empty");
 
     expect(listener).toHaveBeenCalledWith(id, emptyKnownState(id));
   });
@@ -97,7 +92,7 @@ describe("PeerKnownStates", () => {
     const unsubscribe = peerKnownStates.subscribe(listener);
     unsubscribe();
 
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, "empty");
 
     expect(listener).not.toHaveBeenCalled();
   });

package/src/tests/PeerState.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
-import { PeerKnownStateActions } from "../PeerKnownStates.js";
 import { PeerState } from "../PeerState.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
-import { Peer, SyncMessage } from "../sync.js";
+import { CoValueKnownState, Peer, SyncMessage } from "../sync.js";
 
 function setup() {
   const mockPeer: Peer = {
@@ -146,16 +145,11 @@ describe("PeerState", () => {
 
   test("should clone the knownStates into optimisticKnownStates and knownStates when passed as argument", () => {
     const { peerState, mockPeer } = setup();
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    peerState.setKnownState("co_z1", {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
-    };
-    peerState.dispatchToKnownStates(action);
+      header: false,
+      sessions: {},
+    });
 
     const newPeerState = new PeerState(mockPeer, peerState.knownStates);
 
@@ -165,25 +159,26 @@ describe("PeerState", () => {
 
   test("should dispatch to both states", () => {
     const { peerState } = setup();
-    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
+    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
+    if (peerState._optimisticKnownStates === "assumeInfallible") {
+      throw new Error("Expected normal optimisticKnownStates");
+    }
+
     const optimisticKnownStatesSpy = vi.spyOn(
-      peerState.optimisticKnownStates,
-      "dispatch",
+      peerState._optimisticKnownStates,
+      "set",
     );
 
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    const state: CoValueKnownState = {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
+      header: false,
+      sessions: {},
     };
-    peerState.dispatchToKnownStates(action);
 
-    expect(knownStatesSpy).toHaveBeenCalledWith(action);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+    peerState.setKnownState("co_z1", state);
+
+    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith("co_z1", state);
   });
 
   test("should use same reference for knownStates and optimisticKnownStates for storage peers", () => {
@@ -204,28 +199,20 @@ describe("PeerState", () => {
     expect(peerState.knownStates).toBe(peerState.optimisticKnownStates);
 
     // Verify that dispatching only updates one state
-    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
-    const optimisticKnownStatesSpy = vi.spyOn(
-      peerState.optimisticKnownStates,
-      "dispatch",
-    );
+    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
+    expect(peerState._optimisticKnownStates).toBe("assumeInfallible");
 
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    const state: CoValueKnownState = {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
+      header: false,
+      sessions: {},
     };
-    peerState.dispatchToKnownStates(action);
+
+    peerState.setKnownState("co_z1", state);
 
     // Only one dispatch should happen since they're the same reference
     expect(knownStatesSpy).toHaveBeenCalledTimes(1);
-    expect(knownStatesSpy).toHaveBeenCalledWith(action);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledTimes(1);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
   });
 
   test("should use separate references for knownStates and optimisticKnownStates for non-storage peers", () => {