cojson 0.13.10 → 0.13.12

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/coValues/group.ts

@@ -186,8 +186,8 @@ export class RawGroup<
       const child = store.get(id);
 
       if (
-        child.state.type === "unknown" ||
-        child.state.type === "unavailable"
+        child.highLevelState === "unknown" ||
+        child.highLevelState === "unavailable"
       ) {
         child.loadFromPeers(peers).catch(() => {
           logger.error(`Failed to load child group ${id}`);

package/src/exports.ts

@@ -79,8 +79,6 @@ type Value = JsonValue | AnyRawCoValue;
 import { CO_VALUE_LOADING_CONFIG } from "./coValueState.js";
 import { logger } from "./logger.js";
 import { getPriorityFromHeader } from "./priority.js";
-import { FileSystem } from "./storage/FileSystem.js";
-import { BlockFilename, LSMStorage, WalFilename } from "./storage/index.js";
 
 /** @hidden */
 export const cojsonInternals = {
@@ -143,7 +141,6 @@ export {
   CryptoProvider,
   SyncMessage,
   isRawCoID,
-  LSMStorage,
   emptyKnownState,
   RawCoPlainText,
   stringifyOpID,
@@ -154,9 +151,6 @@ export {
 
 export type {
   Value,
-  FileSystem,
-  BlockFilename,
-  WalFilename,
   IncomingSyncStream,
   OutgoingSyncQueue,
   DisconnectedError,

package/src/localNode.ts

@@ -126,7 +126,7 @@ export class LocalNode {
     );
 
     nodeWithAccount.account = controlledAccount;
-    nodeWithAccount.coValuesStore.setAsAvailable(
+    nodeWithAccount.coValuesStore.internalMarkMagicallyAvailable(
       controlledAccount.id,
       controlledAccount.core,
     );
@@ -139,10 +139,8 @@ export class LocalNode {
     // we shouldn't need this, but it fixes account data not syncing for new accounts
     function syncAllCoValuesAfterCreateAccount() {
       for (const coValueEntry of nodeWithAccount.coValuesStore.getValues()) {
-        if (coValueEntry.state.type === "available") {
-          void nodeWithAccount.syncManager.syncCoValue(
-            coValueEntry.state.coValue,
-          );
+        if (coValueEntry.isAvailable()) {
+          void nodeWithAccount.syncManager.syncCoValue(coValueEntry.core);
         }
       }
     }
@@ -208,7 +206,10 @@ export class LocalNode {
       node.syncManager.local = node;
 
       controlledAccount.core.node = node;
-      node.coValuesStore.setAsAvailable(accountID, controlledAccount.core);
+      node.coValuesStore.internalMarkMagicallyAvailable(
+        accountID,
+        controlledAccount.core,
+      );
       controlledAccount.core._cachedContent = undefined;
 
       const profileID = account.get("profile");
@@ -245,7 +246,7 @@ export class LocalNode {
     }
 
     const coValue = new CoValueCore(header, this);
-    this.coValuesStore.setAsAvailable(coValue.id, coValue);
+    this.coValuesStore.internalMarkMagicallyAvailable(coValue.id, coValue);
 
     void this.syncManager.syncCoValue(coValue);
 
@@ -265,10 +266,17 @@ export class LocalNode {
 
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type === "unknown" || entry.state.type === "unavailable") {
+    if (
+      entry.highLevelState === "unknown" ||
+      entry.highLevelState === "unavailable"
+    ) {
       const peers =
         this.syncManager.getServerAndStoragePeers(skipLoadingFromPeer);
 
+      if (peers.length === 0) {
+        return "unavailable";
+      }
+
       await entry.loadFromPeers(peers).catch((e) => {
         logger.error("Error loading from peers", {
           id,
@@ -309,8 +317,8 @@ export class LocalNode {
   getLoaded<T extends RawCoValue>(id: CoID<T>): T | undefined {
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type === "available") {
-      return entry.state.coValue.getCurrentContent() as T;
+    if (entry.isAvailable()) {
+      return entry.core.getCurrentContent() as T;
     }
 
     return undefined;
@@ -439,12 +447,12 @@ export class LocalNode {
   expectCoValueLoaded(id: RawCoID, expectation?: string): CoValueCore {
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type !== "available") {
+    if (!entry.isAvailable()) {
       throw new Error(
-        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded. Current state: ${entry.state.type}`,
+        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded. Current state: ${JSON.stringify(entry)}`,
       );
     }
-    return entry.state.coValue;
+    return entry.core;
   }
 
   /** @internal */
@@ -638,15 +646,13 @@ export class LocalNode {
     while (coValuesToCopy.length > 0) {
       const [coValueID, entry] = coValuesToCopy[coValuesToCopy.length - 1]!;
 
-      if (entry.state.type !== "available") {
+      if (!entry.isAvailable()) {
         coValuesToCopy.pop();
         continue;
       } else {
-        const allDepsCopied = entry.state.coValue
+        const allDepsCopied = entry.core
           .getDependedOnCoValues()
-          .every(
-            (dep) => newNode.coValuesStore.get(dep).state.type === "available",
-          );
+          .every((dep) => newNode.coValuesStore.get(dep).isAvailable());
 
         if (!allDepsCopied) {
           // move to end of queue
@@ -655,12 +661,15 @@ export class LocalNode {
         }
 
         const newCoValue = new CoValueCore(
-          entry.state.coValue.header,
+          entry.core.header,
           newNode,
-          new Map(entry.state.coValue.sessionLogs),
+          new Map(entry.core.sessionLogs),
         );
 
-        newNode.coValuesStore.setAsAvailable(coValueID, newCoValue);
+        newNode.coValuesStore.internalMarkMagicallyAvailable(
+          coValueID,
+          newCoValue,
+        );
 
         coValuesToCopy.pop();
       }