@liveblocks/client 0.13.0-beta.1 → 0.13.3

package/README.md

@@ -8,17 +8,17 @@
 
 **At [Liveblocks](https://liveblocks.io), we’re building tools to help companies create world-class collaborative products that attract, engage and retain users.** This repository is a set of open-source packages for building performant and reliable multiplayer experiences.
 
+## Installation
+
+```
+npm install @liveblocks/client
+```
+
 ## Examples
 
 - Browse our gallery of collaborative UI patterns. [View examples gallery](https://liveblocks.io/examples)
 - Explore and clone any of our open-source examples. [View code examples](https://github.com/liveblocks/liveblocks/tree/main/examples)
 
-## Packages
-
-- [@liveblocks/client](https://github.com/liveblocks/liveblocks/tree/main/packages/liveblocks)
-- [@liveblocks/react](https://github.com/liveblocks/liveblocks/tree/main/packages/liveblocks-react)
-- [@liveblocks/node](https://github.com/liveblocks/liveblocks/tree/main/packages/liveblocks-node)
-
 ## Documentation
 
 [Read the documentation](https://liveblocks.io/docs) to start using Liveblocks.
@@ -35,11 +35,11 @@ For changelog, visit [https://github.com/liveblocks/liveblocks/releases](https:/
 
 ## Community
 
-- [Slack](https://join.slack.com/t/liveblocks-community/shared_invite/zt-qozwnk75-6RB0i1wk1lx470KX0YuZxQ) - To get involved with the Liveblocks community, ask questions and share tips.
+- [Discord](https://discord.gg/X4YWJuH9VY) - To get involved with the Liveblocks community, ask questions and share tips.
 - [Twitter](https://twitter.com/liveblocks) - To receive updates, announcements, blog posts, and general Liveblocks tips.
 
 ## License
 
 Licensed under the Apache License 2.0, Copyright © 2021-present [Liveblocks](https://liveblocks.io).
 
-See [LICENSE](./LICENSE) for more information.
+See [LICENSE](../../LICENSE) for more information.

package/lib/cjs/LiveList.d.ts

@@ -64,6 +64,7 @@ export declare class LiveList<T> extends AbstractCrdt {
      * @param index The index of the element to delete
      */
     delete(index: number): void;
+    clear(): void;
     /**
      * Returns an Array of all the elements in the LiveList.
      */

package/lib/cjs/LiveList.js

@@ -256,6 +256,28 @@ class LiveList extends AbstractCrdt_1.AbstractCrdt {
             }
         }
     }
+    clear() {
+        if (this._doc) {
+            let ops = [];
+            let reverseOps = [];
+            for (const item of __classPrivateFieldGet(this, _LiveList_items, "f")) {
+                item[0]._detach();
+                const childId = item[0]._id;
+                if (childId) {
+                    ops.push({ id: childId, type: live_1.OpType.DeleteCrdt });
+                    reverseOps.push(...item[0]._serialize(this._id, item[1]));
+                }
+            }
+            __classPrivateFieldSet(this, _LiveList_items, [], "f");
+            this._doc.dispatch(ops, reverseOps, [this]);
+        }
+        else {
+            for (const item of __classPrivateFieldGet(this, _LiveList_items, "f")) {
+                item[0]._detach();
+            }
+            __classPrivateFieldSet(this, _LiveList_items, [], "f");
+        }
+    }
     /**
      * Returns an Array of all the elements in the LiveList.
      */

package/lib/cjs/LiveObject.d.ts

@@ -53,6 +53,11 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
      * @param key The key of the property to get
      */
     get<TKey extends keyof T>(key: TKey): T[TKey];
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key: keyof T): void;
     /**
      * Adds or updates multiple properties at once with an object.
      * @param overrides The object used to overrides properties

package/lib/cjs/LiveObject.js

@@ -186,6 +186,40 @@ class LiveObject extends AbstractCrdt_1.AbstractCrdt {
     get(key) {
         return __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
     }
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key) {
+        const keyAsString = key;
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(keyAsString);
+        if (oldValue === undefined) {
+            return;
+        }
+        if (this._doc == null || this._id == null) {
+            if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                oldValue._detach();
+            }
+            __classPrivateFieldGet(this, _LiveObject_map, "f").delete(keyAsString);
+            return;
+        }
+        let reverse;
+        if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+            oldValue._detach();
+            reverse = oldValue._serialize(this._id, keyAsString);
+        }
+        else {
+            reverse = [
+                {
+                    type: live_1.OpType.UpdateObject,
+                    data: { [keyAsString]: oldValue },
+                    id: this._id,
+                },
+            ];
+        }
+        __classPrivateFieldGet(this, _LiveObject_map, "f").delete(keyAsString);
+        this._doc.dispatch([{ type: live_1.OpType.DeleteObjectKey, key: keyAsString, id: this._id }], reverse, [this]);
+    }
     /**
      * Adds or updates multiple properties at once with an object.
      * @param overrides The object used to overrides properties
@@ -310,6 +344,10 @@ _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _
     return isModified ? { modified: this, reverse } : { modified: false };
 }, _LiveObject_applyDeleteObjectKey = function _LiveObject_applyDeleteObjectKey(op) {
     const key = op.key;
+    // If property does not exist, exit without notifying
+    if (__classPrivateFieldGet(this, _LiveObject_map, "f").has(key) === false) {
+        return { modified: false };
+    }
     const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
     let reverse = [];
     if ((0, utils_1.isCrdt)(oldValue)) {

package/lib/cjs/immutable/index.d.ts

@@ -0,0 +1,7 @@
+import { LiveList } from "../LiveList";
+import { LiveObject } from "../LiveObject";
+import { StorageUpdate } from "../types";
+export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
+export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
+export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
+export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/cjs/immutable/index.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchImmutableObject = exports.patchLiveObject = exports.patchLiveList = exports.liveObjectToJson = void 0;
+const LiveList_1 = require("../LiveList");
+const LiveMap_1 = require("../LiveMap");
+const LiveObject_1 = require("../LiveObject");
+function liveObjectToJson(liveObject) {
+    const result = {};
+    const obj = liveObject.toObject();
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+exports.liveObjectToJson = liveObjectToJson;
+function liveMapToJson(map) {
+    const result = {};
+    const obj = Object.fromEntries(map);
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+function liveListToJson(value) {
+    return value.toArray().map(liveNodeToJson);
+}
+function liveNodeToJson(value) {
+    if (value instanceof LiveObject_1.LiveObject) {
+        return liveObjectToJson(value);
+    }
+    else if (value instanceof LiveList_1.LiveList) {
+        return liveListToJson(value);
+    }
+    else if (value instanceof LiveMap_1.LiveMap) {
+        return liveMapToJson(value);
+    }
+    return value;
+}
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function anyToCrdt(obj) {
+    if (obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return new LiveList_1.LiveList(obj.map(anyToCrdt));
+    }
+    if (isPlainObject(obj)) {
+        const init = {};
+        for (const key in obj) {
+            init[key] = anyToCrdt(obj[key]);
+        }
+        return new LiveObject_1.LiveObject(init);
+    }
+    return obj;
+}
+function patchLiveList(liveList, prev, next) {
+    let i = 0;
+    let prevEnd = prev.length - 1;
+    let nextEnd = next.length - 1;
+    let prevNode = prev[0];
+    let nextNode = next[0];
+    /**
+     * For A,B,C => A,B,C,D
+     * i = 3, prevEnd = 2, nextEnd = 3
+     *
+     * For A,B,C => B,C
+     * i = 2, prevEnd = 2, nextEnd = 1
+     *
+     * For B,C => A,B,C
+     * i = 0, pre
+     */
+    outer: {
+        while (prevNode === nextNode) {
+            ++i;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[i];
+            nextNode = next[i];
+        }
+        prevNode = prev[prevEnd];
+        nextNode = next[nextEnd];
+        while (prevNode === nextNode) {
+            prevEnd--;
+            nextEnd--;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[prevEnd];
+            nextNode = next[nextEnd];
+        }
+    }
+    if (i > prevEnd) {
+        if (i <= nextEnd) {
+            while (i <= nextEnd) {
+                liveList.insert(anyToCrdt(next[i]), i);
+                i++;
+            }
+        }
+    }
+    else if (i > nextEnd) {
+        while (i <= prevEnd) {
+            liveList.delete(i++);
+        }
+    }
+    else {
+        while (i <= prevEnd && i <= nextEnd) {
+            prevNode = prev[i];
+            nextNode = next[i];
+            const liveListNode = liveList.get(i);
+            if (liveListNode instanceof LiveObject_1.LiveObject &&
+                isPlainObject(prevNode) &&
+                isPlainObject(nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            }
+            else {
+                liveList.delete(i);
+                liveList.insert(anyToCrdt(nextNode), i);
+            }
+            i++;
+        }
+        while (i <= nextEnd) {
+            liveList.insert(anyToCrdt(next[i]), i);
+            i++;
+        }
+        while (i <= prevEnd) {
+            liveList.delete(i);
+            i++;
+        }
+    }
+}
+exports.patchLiveList = patchLiveList;
+function patchLiveObject(root, prev, next) {
+    const updates = {};
+    for (const key in next) {
+        if (prev[key] === next[key]) {
+            continue;
+        }
+        else if (Array.isArray(prev[key]) && Array.isArray(next[key])) {
+            patchLiveList(root.get(key), prev[key], next[key]);
+        }
+        else if (isPlainObject(prev[key]) && isPlainObject(next[key])) {
+            patchLiveObject(root.get(key), prev[key], next[key]);
+        }
+        else {
+            updates[key] = anyToCrdt(next[key]);
+        }
+    }
+    for (const key in prev) {
+        if (next[key] === undefined) {
+            root.delete(key);
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        root.update(updates);
+    }
+}
+exports.patchLiveObject = patchLiveObject;
+function getParentsPath(node) {
+    const path = [];
+    while (node._parentKey != null && node._parent != null) {
+        if (node._parent instanceof LiveList_1.LiveList) {
+            path.push(node._parent._indexOfPosition(node._parentKey));
+        }
+        else {
+            path.push(node._parentKey);
+        }
+        node = node._parent;
+    }
+    return path;
+}
+function patchImmutableObject(state, updates) {
+    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
+}
+exports.patchImmutableObject = patchImmutableObject;
+function patchImmutableObjectWithUpdate(state, update) {
+    const path = getParentsPath(update.node);
+    return patchImmutableNode(state, path, update);
+}
+function patchImmutableNode(state, path, update) {
+    const pathItem = path.pop();
+    if (pathItem === undefined) {
+        switch (update.type) {
+            case "LiveObject": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveObject but state was not an object");
+                }
+                return liveObjectToJson(update.node);
+            }
+            case "LiveList": {
+                if (Array.isArray(state) === false) {
+                    throw new Error("Internal: received update on LiveList but state was not an array");
+                }
+                return liveListToJson(update.node);
+            }
+            case "LiveMap": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveMap but state was not an object");
+                }
+                return liveMapToJson(update.node);
+            }
+        }
+    }
+    if (Array.isArray(state)) {
+        const newArray = [...state];
+        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+        return newArray;
+    }
+    else {
+        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
+    }
+}

package/lib/cjs/immutable.d.ts

@@ -0,0 +1,8 @@
+import { LiveList } from "./LiveList";
+import { LiveObject } from "./LiveObject";
+import { StorageUpdate } from "./types";
+export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
+export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
+export declare function patchLiveObjectKey<T>(liveObject: LiveObject<T>, key: keyof T, prev: any, next: any): void;
+export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
+export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/cjs/immutable.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchImmutableObject = exports.patchLiveObject = exports.patchLiveObjectKey = exports.patchLiveList = exports.liveObjectToJson = void 0;
+const LiveList_1 = require("./LiveList");
+const LiveMap_1 = require("./LiveMap");
+const LiveObject_1 = require("./LiveObject");
+const LiveRegister_1 = require("./LiveRegister");
+function liveObjectToJson(liveObject) {
+    const result = {};
+    const obj = liveObject.toObject();
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+exports.liveObjectToJson = liveObjectToJson;
+function liveMapToJson(map) {
+    const result = {};
+    const obj = Object.fromEntries(map);
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+function liveListToJson(value) {
+    return value.toArray().map(liveNodeToJson);
+}
+function liveNodeToJson(value) {
+    if (value instanceof LiveObject_1.LiveObject) {
+        return liveObjectToJson(value);
+    }
+    else if (value instanceof LiveList_1.LiveList) {
+        return liveListToJson(value);
+    }
+    else if (value instanceof LiveMap_1.LiveMap) {
+        return liveMapToJson(value);
+    }
+    else if (value instanceof LiveRegister_1.LiveRegister) {
+        return value.data;
+    }
+    return value;
+}
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function anyToCrdt(obj) {
+    if (obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return new LiveList_1.LiveList(obj.map(anyToCrdt));
+    }
+    if (isPlainObject(obj)) {
+        const init = {};
+        for (const key in obj) {
+            init[key] = anyToCrdt(obj[key]);
+        }
+        return new LiveObject_1.LiveObject(init);
+    }
+    return obj;
+}
+function patchLiveList(liveList, prev, next) {
+    let i = 0;
+    let prevEnd = prev.length - 1;
+    let nextEnd = next.length - 1;
+    let prevNode = prev[0];
+    let nextNode = next[0];
+    /**
+     * For A,B,C => A,B,C,D
+     * i = 3, prevEnd = 2, nextEnd = 3
+     *
+     * For A,B,C => B,C
+     * i = 2, prevEnd = 2, nextEnd = 1
+     *
+     * For B,C => A,B,C
+     * i = 0, pre
+     */
+    outer: {
+        while (prevNode === nextNode) {
+            ++i;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[i];
+            nextNode = next[i];
+        }
+        prevNode = prev[prevEnd];
+        nextNode = next[nextEnd];
+        while (prevNode === nextNode) {
+            prevEnd--;
+            nextEnd--;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[prevEnd];
+            nextNode = next[nextEnd];
+        }
+    }
+    if (i > prevEnd) {
+        if (i <= nextEnd) {
+            while (i <= nextEnd) {
+                liveList.insert(anyToCrdt(next[i]), i);
+                i++;
+            }
+        }
+    }
+    else if (i > nextEnd) {
+        while (i <= prevEnd) {
+            liveList.delete(i++);
+        }
+    }
+    else {
+        while (i <= prevEnd && i <= nextEnd) {
+            prevNode = prev[i];
+            nextNode = next[i];
+            const liveListNode = liveList.get(i);
+            if (liveListNode instanceof LiveObject_1.LiveObject &&
+                isPlainObject(prevNode) &&
+                isPlainObject(nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            }
+            else {
+                liveList.delete(i);
+                liveList.insert(anyToCrdt(nextNode), i);
+            }
+            i++;
+        }
+        while (i <= nextEnd) {
+            liveList.insert(anyToCrdt(next[i]), i);
+            i++;
+        }
+        while (i <= prevEnd) {
+            liveList.delete(i);
+            i++;
+        }
+    }
+}
+exports.patchLiveList = patchLiveList;
+function patchLiveObjectKey(liveObject, key, prev, next) {
+    const value = liveObject.get(key);
+    if (next === undefined) {
+        liveObject.delete(key);
+    }
+    else if (value === undefined) {
+        liveObject.set(key, anyToCrdt(next));
+    }
+    else if (prev === next) {
+        return;
+    }
+    else if (value instanceof LiveList_1.LiveList &&
+        Array.isArray(prev) &&
+        Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    }
+    else if (value instanceof LiveObject_1.LiveObject &&
+        isPlainObject(prev) &&
+        isPlainObject(next)) {
+        patchLiveObject(value, prev, next);
+    }
+    else {
+        liveObject.set(key, anyToCrdt(next));
+    }
+}
+exports.patchLiveObjectKey = patchLiveObjectKey;
+function patchLiveObject(root, prev, next) {
+    const updates = {};
+    for (const key in next) {
+        patchLiveObjectKey(root, key, prev[key], next[key]);
+    }
+    for (const key in prev) {
+        if (next[key] === undefined) {
+            root.delete(key);
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        root.update(updates);
+    }
+}
+exports.patchLiveObject = patchLiveObject;
+function getParentsPath(node) {
+    const path = [];
+    while (node._parentKey != null && node._parent != null) {
+        if (node._parent instanceof LiveList_1.LiveList) {
+            path.push(node._parent._indexOfPosition(node._parentKey));
+        }
+        else {
+            path.push(node._parentKey);
+        }
+        node = node._parent;
+    }
+    return path;
+}
+function patchImmutableObject(state, updates) {
+    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
+}
+exports.patchImmutableObject = patchImmutableObject;
+function patchImmutableObjectWithUpdate(state, update) {
+    const path = getParentsPath(update.node);
+    return patchImmutableNode(state, path, update);
+}
+function patchImmutableNode(state, path, update) {
+    const pathItem = path.pop();
+    if (pathItem === undefined) {
+        switch (update.type) {
+            case "LiveObject": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveObject but state was not an object");
+                }
+                return liveObjectToJson(update.node);
+            }
+            case "LiveList": {
+                if (Array.isArray(state) === false) {
+                    throw new Error("Internal: received update on LiveList but state was not an array");
+                }
+                return liveListToJson(update.node);
+            }
+            case "LiveMap": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveMap but state was not an object");
+                }
+                return liveMapToJson(update.node);
+            }
+        }
+    }
+    if (Array.isArray(state)) {
+        const newArray = [...state];
+        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+        return newArray;
+    }
+    else {
+        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
+    }
+}

package/lib/cjs/index.d.ts

@@ -1,5 +1,5 @@
 export { LiveObject } from "./LiveObject";
 export { LiveMap } from "./LiveMap";
 export { LiveList } from "./LiveList";
-export type { Others, Presence, Room, Client, User } from "./types";
+export type { Others, Presence, Room, Client, User, BroadcastOptions, } from "./types";
 export { createClient } from "./client";

package/lib/cjs/room.d.ts

@@ -1,4 +1,4 @@
-import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate } from "./types";
+import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate, BroadcastOptions } from "./types";
 import { ClientMessage, Op } from "./live";
 import { LiveMap } from "./LiveMap";
 import { LiveObject } from "./LiveObject";
@@ -118,7 +118,7 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>, options?: {
         addToHistory: boolean;
     } | undefined) => void;
-    broadcastEvent: (event: any) => void;
+    broadcastEvent: (event: any, options?: BroadcastOptions) => void;
     batch: (callback: () => void) => void;
     undo: () => void;
     redo: () => void;