loro-crdt 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.1.2
+
+### Patch Changes
+
+- 70c4942: Add base64 build target
+- 35e7ea5: Add changeCount and opCount methods
+
+## 1.1.1
+
+### Patch Changes
+
+- 9abeb81: Add methods to modify VV
+- ee26952: Add isDeleted() method to each container
+
 ## 1.1.0
 
 ### Minor 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/base64/index.d.ts

@@ -0,0 +1,72 @@
+export * from "./loro_wasm";
+export type * from "./loro_wasm";
+import { AwarenessWasm, PeerID, Container, ContainerID, ContainerType, LoroCounter, LoroDoc, LoroList, LoroMap, LoroText, LoroTree, OpId, Value, AwarenessListener } from "./loro_wasm";
+/**
+ * @deprecated Please use LoroDoc
+ */
+export declare class Loro extends LoroDoc {
+}
+export declare function isContainerId(s: string): s is ContainerID;
+/**  Whether the value is a container.
+ *
+ * # Example
+ *
+ * ```ts
+ * const doc = new LoroDoc();
+ * const map = doc.getMap("map");
+ * const list = doc.getList("list");
+ * const text = doc.getText("text");
+ * isContainer(map); // true
+ * isContainer(list); // true
+ * isContainer(text); // true
+ * isContainer(123); // false
+ * isContainer("123"); // false
+ * isContainer({}); // false
+ * ```
+ */
+export declare function isContainer(value: any): value is Container;
+/**  Get the type of a value that may be a container.
+ *
+ * # Example
+ *
+ * ```ts
+ * const doc = new LoroDoc();
+ * const map = doc.getMap("map");
+ * const list = doc.getList("list");
+ * const text = doc.getText("text");
+ * getType(map); // "Map"
+ * getType(list); // "List"
+ * getType(text); // "Text"
+ * getType(123); // "Json"
+ * getType("123"); // "Json"
+ * getType({}); // "Json"
+ * ```
+ */
+export declare function getType<T>(value: T): T extends LoroText ? "Text" : T extends LoroMap<any> ? "Map" : T extends LoroTree<any> ? "Tree" : T extends LoroList<any> ? "List" : T extends LoroCounter ? "Counter" : "Json";
+export declare function newContainerID(id: OpId, type: ContainerType): ContainerID;
+export declare function newRootContainerID(name: string, type: ContainerType): ContainerID;
+/**
+ * Awareness is a structure that allows to track the ephemeral state of the peers.
+ *
+ * If we don't receive a state update from a peer within the timeout, we will remove their state.
+ * The timeout is in milliseconds. This can be used to handle the off-line state of a peer.
+ */
+export declare class Awareness<T extends Value = Value> {
+    inner: AwarenessWasm<T>;
+    private peer;
+    private timer;
+    private timeout;
+    private listeners;
+    constructor(peer: PeerID, timeout?: number);
+    apply(bytes: Uint8Array, origin?: string): void;
+    setLocalState(state: T): void;
+    getLocalState(): T | undefined;
+    getAllStates(): Record<PeerID, T>;
+    encode(peers: PeerID[]): Uint8Array;
+    encodeAll(): Uint8Array;
+    addListener(listener: AwarenessListener): void;
+    removeListener(listener: AwarenessListener): void;
+    peers(): PeerID[];
+    destroy(): void;
+    private startTimerIfNotEmpty;
+}