loro-crdt 1.0.9 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 1.1.1
+
+### Patch Changes
+
+- 9abeb81: Add methods to modify VV
+- ee26952: Add isDeleted() method to each container
+
+## 1.1.0
+
+### Minor Changes
+
+- 6e878d2: Feat add API to query creators, the last editors/movers
+- 778ca54: Feat: allow users to query the changed containers in the target id range
+
+### Patch Changes
+
+- 6616101: Perf: optimize importBatch
+
+  When using importBatch to import a series of snapshots and updates, we should import the snapshot with the greatest version first.
+
+- 6e878d2: Feat: getLastEditor on LoroMap
+- 8486234: Fix get encoded blob meta
+
 ## 1.0.9
 
 ### Patch Changes

package/README.md

@@ -9,8 +9,7 @@
 <a href="https://loro.dev" alt="loro-site">Loro</a>
 </h1>
 <p align="center">
-  <b>Reimagine state management with CRDTs 🦜</b><br/>
-  Make your app state synchronized and collaborative effortlessly.
+  <b>Make your JSON data collaborative and version-controlled 🦜</b>
 </p>
 <p align="center">
   <a href="https://trendshift.io/repositories/4964" target="_blank"><img src="https://trendshift.io/api/badge/repositories/4964" alt="loro-dev%2Floro | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
@@ -42,11 +41,11 @@
   ✨ Loro 1.0 is out! Read the <a href="https://loro.dev/blog/v1.0">announcement</a>.
 </h4>
 
-Loro is a [CRDTs(Conflict-free Replicated Data Types)](https://crdt.tech/) library that makes building [local-first apps][local-first] easier. It is currently available for JavaScript (via WASM) and Rust developers.
+Loro is a [CRDTs(Conflict-free Replicated Data Types)](https://crdt.tech/) library that makes building [local-first][local-first] and collaborative apps easier. You can now use it in Rust, JS (via WASM), and Swift.
 
 # Features
 
-**Basic Features Provided by CRDTs**
+**Features Provided by CRDTs**
 
 - P2P Synchronization
 - Automatic Merging
@@ -61,10 +60,10 @@ Loro is a [CRDTs(Conflict-free Replicated Data Types)](https://crdt.tech/) libra
 - 🌲 [Moveable Tree](https://loro.dev/docs/tutorial/tree)
 - 🚗 [Moveable List](https://loro.dev/docs/tutorial/list)
 - 🗺️ [Last-Write-Wins Map](https://loro.dev/docs/tutorial/map)
-- 🔄 [Replayable Event Graph](https://loro.dev/docs/advanced/replayable_event_graph)
 
 **Advanced Features in Loro**
 
+- 🚀 [Fast Document Loading](https://loro.dev/blog/v1.0)
 - ⏱️ Fast [Time Travel](https://loro.dev/docs/tutorial/time_travel) Through History
 - 🏛️ [Version Control with Real-Time Collaboration](https://loro.dev/blog/v1.0#version-control)
 - 📦 [Shallow Snapshot](https://loro.dev/docs/advanced/shallow_snapshot) that Works like Git Shallow Clone 
@@ -82,9 +81,8 @@ import { expect, test } from 'vitest';
 import { LoroDoc, LoroList } from 'loro-crdt';
 
 test('sync example', () => {
-  /**
-   * Demonstrates synchronization of two documents with two rounds of exchanges.
-   */
+  // Sync two docs with two rounds of exchanges
+
   // Initialize document A
   const docA = new LoroDoc();
   const listA: LoroList = docA.getList('list');
@@ -92,34 +90,36 @@ test('sync example', () => {
   listA.insert(1, 'B');
   listA.insert(2, 'C');
 
-  // Export the state of document A as a byte array
+  // Export all updates from docA
   const bytes: Uint8Array = docA.export({ mode: 'update' });
 
   // Simulate sending `bytes` across the network to another peer, B
+
   const docB = new LoroDoc();
   // Peer B imports the updates from A
   docB.import(bytes);
 
-  // Verify that B's state matches A's state
+  // B's state matches A's state
   expect(docB.toJSON()).toStrictEqual({
     list: ['A', 'B', 'C'],
   });
 
-  // Get the current operation log version of document B
+  // Get the current version of docB
   const version = docB.oplogVersion();
 
   // Simulate editing at B: delete item 'B'
   const listB: LoroList = docB.getList('list');
   listB.delete(1, 1);
 
-  // Export the updates from B since the last synchronization point
+  // Export the updates from B since the last sync point
   const bytesB: Uint8Array = docB.export({ mode: 'update', from: version });
 
   // Simulate sending `bytesB` back across the network to A
+
   // A imports the updates from B
   docA.import(bytesB);
 
-  // Verify that the list at A now matches the list at B after merging
+  // A has the same state as B
   expect(docA.toJSON()).toStrictEqual({
     list: ['A', 'C'],
   });

package/bundler/loro_wasm.d.ts

@@ -26,12 +26,13 @@ export function setDebug(): void;
 * - endVersionVector
 * - startTimestamp
 * - endTimestamp
-* - isSnapshot
+* - mode
 * - changeNum
 * @param {Uint8Array} blob
+* @param {boolean} check_checksum
 * @returns {ImportBlobMetadata}
 */
-export function decodeImportBlobMeta(blob: Uint8Array): ImportBlobMetadata;
+export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean): ImportBlobMetadata;
 
 /**
 * Container types supported by loro.
@@ -262,7 +263,7 @@ export interface ImportBlobMetadata {
     startFrontiers: OpId[],
     startTimestamp: number;
     endTimestamp: number;
-    isSnapshot: boolean;
+    mode: "outdated-snapshot" | "outdated-update" | "snapshot" | "shallow-snapshot" | "update";
     changeNum: number;
 }
 
@@ -351,6 +352,11 @@ export type TreeNodeValue = {
     children: TreeNodeValue[],
 }
 
+export type TreeNodeJSON<T> = Omit<TreeNodeValue, 'meta' | 'children'> & {
+    meta: T,
+    children: TreeNodeJSON<T>[],
+}
+
 interface LoroTree{
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted: boolean = false }): LoroTreeNode[];
@@ -432,6 +438,11 @@ export type JsonChange = {
   ops: JsonOp[]
 }
 
+export interface TextUpdateOptions {
+    timeoutMs?: number,
+    useRefinedDiff?: boolean,
+}
+
 export type ExportMode = {
     mode: "update",
     from?: VersionVector,
@@ -1012,6 +1023,32 @@ interface LoroText {
     insert(pos: number, text: string): void;
     delete(pos: number, len: number): void;
     subscribe(listener: Listener): Subscription;
+    /**
+     * Update the current text to the target text.
+     *
+     * It will calculate the minimal difference and apply it to the current text.
+     * It uses Myers' diff algorithm to compute the optimal difference.
+     *
+     * This could take a long time for large texts (e.g. > 50_000 characters).
+     * In that case, you should use `updateByLine` instead.
+     *
+     * @example
+     * ```ts
+     * import { LoroDoc } from "loro-crdt";
+     *
+     * const doc = new LoroDoc();
+     * const text = doc.getText("text");
+     * text.insert(0, "Hello");
+     * text.update("Hello World");
+     * console.log(text.toString()); // "Hello World"
+     * ```
+     */
+    update(text: string, options?: TextUpdateOptions): void;
+    /**
+     * Update the current text based on the provided text.
+     * This update calculation is line-based, which will be more efficient but less precise.
+     */
+    updateByLine(text: string, options?: TextUpdateOptions): void;
 }
 interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroTree<T>;
@@ -1080,6 +1117,7 @@ interface LoroTreeNode<T extends Record<string, unknown> = Record<string, unknow
      * the WASM boundary.
      */
     children(): Array<LoroTreeNode<T>> | undefined;
+    toJSON(): TreeNodeJSON<T>;
 }
 interface AwarenessWasm<T extends Value = Value> {
     getState(peer: PeerID): T | undefined;
@@ -1532,9 +1570,9 @@ export class LoroDoc {
 * @param ids - the changes to visit
 * @param f - the callback function, return `true` to continue visiting, return `false` to stop
 * @param {({ peer: PeerID, counter: number })[]} ids
-* @param {Function} f
+* @param {(change: ChangeMeta) => boolean} f
 */
-  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: Function): void;
+  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: (change: ChangeMeta) => boolean): void;
 /**
 * Checkout the `DocState` to a specific version.
 *
@@ -1638,9 +1676,9 @@ export class LoroDoc {
 /**
 * Get the path from the root to the container
 * @param {ContainerID} id
-* @returns {Array<any> | undefined}
+* @returns {(string|number)[] | undefined}
 */
-  getPathToContainer(id: ContainerID): Array<any> | undefined;
+  getPathToContainer(id: ContainerID): (string|number)[] | undefined;
 /**
 * Evaluate JSONPath against a LoroDoc
 * @param {string} jsonpath
@@ -2010,6 +2048,23 @@ export class LoroDoc {
 */
   getCursorPos(cursor: Cursor): { update?: Cursor, offset: number, side: Side };
 /**
+* Gets container IDs modified in the given ID range.
+*
+* **NOTE:** This method will implicitly commit.
+*
+* This method identifies which containers were affected by changes in a given range of operations.
+* It can be used together with `doc.travelChangeAncestors()` to analyze the history of changes
+* and determine which containers were modified by each change.
+*
+* @param id - The starting ID of the change range
+* @param len - The length of the change range to check
+* @returns An array of container IDs that were modified in the given range
+* @param {{ peer: PeerID, counter: number }} id
+* @param {number} len
+* @returns {(ContainerID)[]}
+*/
+  getChangedContainersIn(id: { peer: PeerID, counter: number }, len: number): (ContainerID)[];
+/**
 * Peer ID of the current writer.
 */
   readonly peerId: bigint;
@@ -2105,6 +2160,16 @@ export class LoroList {
 */
   clear(): void;
 /**
+* @param {number} pos
+* @returns {{ peer: PeerID, counter: number } | undefined}
+*/
+  getIdAt(pos: number): { peer: PeerID, counter: number } | undefined;
+/**
+* Check if the container is deleted
+* @returns {boolean}
+*/
+  isDeleted(): boolean;
+/**
 * Get the id of this container.
 */
   readonly id: ContainerID;
@@ -2255,6 +2320,17 @@ export class LoroMap {
 */
   clear(): void;
 /**
+* Get the peer id of the last editor on the given entry
+* @param {string} key
+* @returns {PeerID | undefined}
+*/
+  getLastEditor(key: string): PeerID | undefined;
+/**
+* Check if the container is deleted
+* @returns {boolean}
+*/
+  isDeleted(): boolean;
+/**
 * The container id of this handler.
 */
   readonly id: ContainerID;
@@ -2375,6 +2451,29 @@ export class LoroMovableList {
 */
   clear(): void;
 /**
+* Get the creator of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getCreatorAt(pos: number): PeerID | undefined;
+/**
+* Get the last mover of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getLastMoverAt(pos: number): PeerID | undefined;
+/**
+* Get the last editor of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getLastEditorAt(pos: number): PeerID | undefined;
+/**
+* Check if the container is deleted
+* @returns {boolean}
+*/
+  isDeleted(): boolean;
+/**
 * Get the id of this container.
 */
   readonly id: ContainerID;
@@ -2415,11 +2514,14 @@ export class LoroText {
 */
   kind(): 'Text';
 /**
-* Iterate each span(internal storage unit) of the text.
+* Iterate each text span(internal storage unit)
 *
 * The callback function will be called for each span in the text.
 * If the callback returns `false`, the iteration will stop.
 *
+* Limitation: you cannot access or alter the doc state when iterating (this is for performance consideration).
+* If you need to access or alter the doc state, please use `toString` instead.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt";
@@ -2433,35 +2535,6 @@ export class LoroText {
 */
   iter(callback: Function): void;
 /**
-* Update the current text to the target text.
-*
-* It will calculate the minimal difference and apply it to the current text.
-* It uses Myers' diff algorithm to compute the optimal difference.
-*
-* This could take a long time for large texts (e.g. > 50_000 characters).
-* In that case, you should use `updateByLine` instead.
-*
-* @example
-* ```ts
-* import { LoroDoc } from "loro-crdt";
-*
-* const doc = new LoroDoc();
-* const text = doc.getText("text");
-* text.insert(0, "Hello");
-* text.update("Hello World");
-* console.log(text.toString()); // "Hello World"
-* ```
-* @param {string} text
-*/
-  update(text: string): void;
-/**
-* Update the current text to the target text, the difference is calculated line by line.
-*
-* It uses Myers' diff algorithm to compute the optimal difference.
-* @param {string} text
-*/
-  updateByLine(text: string): void;
-/**
 * Insert the string at the given index (utf-16 index).
 *
 * @example
@@ -2705,6 +2778,17 @@ export class LoroText {
 */
   push(s: string): void;
 /**
+* Get the editor of the text at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getEditorOf(pos: number): PeerID | undefined;
+/**
+* Check if the container is deleted
+* @returns {boolean}
+*/
+  isDeleted(): boolean;
+/**
 * Get the container id of the text.
 */
   readonly id: ContainerID;
@@ -2869,6 +2953,11 @@ export class LoroTree {
 */
   isFractionalIndexEnabled(): boolean;
 /**
+* Check if the container is deleted
+* @returns {boolean}
+*/
+  isDeleted(): boolean;
+/**
 * Get the id of the container.
 */
   readonly id: ContainerID;
@@ -2974,6 +3063,21 @@ export class LoroTreeNode {
 */
   isDeleted(): boolean;
 /**
+* Get the last mover of this node.
+* @returns {{ peer: PeerID, counter: number } | undefined}
+*/
+  getLastMoveId(): { peer: PeerID, counter: number } | undefined;
+/**
+* Get the creation id of this node.
+* @returns {{ peer: PeerID, counter: number }}
+*/
+  creationId(): { peer: PeerID, counter: number };
+/**
+* Get the creator of this node.
+* @returns {PeerID}
+*/
+  creator(): PeerID;
+/**
 * The TreeID of the node.
 */
   readonly id: TreeID;
@@ -3118,4 +3222,22 @@ export class VersionVector {
 * @returns {number | undefined}
 */
   compare(other: VersionVector): number | undefined;
+/**
+* set the exclusive ending point. target id will NOT be included by self
+* @param {{ peer: PeerID, counter: number }} id
+*/
+  setEnd(id: { peer: PeerID, counter: number }): void;
+/**
+* set the inclusive ending point. target id will be included
+* @param {{ peer: PeerID, counter: number }} id
+*/
+  setLast(id: { peer: PeerID, counter: number }): void;
+/**
+* @param {PeerID} peer
+*/
+  remove(peer: PeerID): void;
+/**
+* @returns {number}
+*/
+  length(): number;
 }