@liveblocks/client 0.12.3 → 0.13.2

package/lib/cjs/LiveObject.js

@@ -0,0 +1,368 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LiveObject_instances, _LiveObject_map, _LiveObject_propToLastUpdate, _LiveObject_applyUpdate, _LiveObject_applyDeleteObjectKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveObject = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const utils_1 = require("./utils");
+const live_1 = require("./live");
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveObject extends AbstractCrdt_1.AbstractCrdt {
+    constructor(object = {}) {
+        super();
+        _LiveObject_instances.add(this);
+        _LiveObject_map.set(this, void 0);
+        _LiveObject_propToLastUpdate.set(this, new Map());
+        for (const key in object) {
+            const value = object[key];
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                value._setParentLink(this, key);
+            }
+        }
+        __classPrivateFieldSet(this, _LiveObject_map, new Map(Object.entries(object)), "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            type: live_1.OpType.CreateObject,
+            parentId,
+            parentKey,
+            data: {},
+        };
+        ops.push(op);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                ops.push(...value._serialize(this._id, key));
+            }
+            else {
+                op.data[key] = value;
+            }
+        }
+        return ops;
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Object) {
+            throw new Error(`Tried to deserialize a record but item type is "${item.type}"`);
+        }
+        const object = new LiveObject(item.data);
+        object._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return object;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = (0, utils_1.deserialize)(entry, parentToChildren, doc);
+            child._setParentLink(object, crdt.parentKey);
+            __classPrivateFieldGet(object, _LiveObject_map, "f").set(crdt.parentKey, child);
+        }
+        return object;
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _attachChild(id, key, child) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const previousValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        let reverse;
+        if ((0, utils_1.isCrdt)(previousValue)) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else if (previousValue === undefined) {
+            reverse = [
+                { type: live_1.OpType.DeleteObjectKey, id: this._id, key: key },
+            ];
+        }
+        else {
+            reverse = [
+                {
+                    type: live_1.OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: previousValue },
+                },
+            ];
+        }
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, child);
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        return { reverse, modified: this };
+    }
+    /**
+     * INTERNAL
+     */
+    _detachChild(child) {
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value === child) {
+                __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+            }
+        }
+        if (child) {
+            child._detach();
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        super._detach();
+        for (const value of __classPrivateFieldGet(this, _LiveObject_map, "f").values()) {
+            if ((0, utils_1.isCrdt)(value)) {
+                value._detach();
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        if (op.type === live_1.OpType.UpdateObject) {
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyUpdate).call(this, op);
+        }
+        else if (op.type === live_1.OpType.DeleteObjectKey) {
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyDeleteObjectKey).call(this, op);
+        }
+        return super._apply(op);
+    }
+    /**
+     * Transform the LiveObject into a javascript object
+     */
+    toObject() {
+        return Object.fromEntries(__classPrivateFieldGet(this, _LiveObject_map, "f"));
+    }
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
+    set(key, value) {
+        // TODO: Find out why typescript complains
+        this.update({ [key]: value });
+    }
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    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
+     */
+    update(overrides) {
+        if (this._doc == null || this._id == null) {
+            for (const key in overrides) {
+                const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+                if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    oldValue._detach();
+                }
+                const newValue = overrides[key];
+                if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    newValue._setParentLink(this, key);
+                }
+                __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+            }
+            return;
+        }
+        const ops = [];
+        const reverseOps = [];
+        const opId = this._doc.generateOpId();
+        const updatedProps = {};
+        const reverseUpdateOp = {
+            id: this._id,
+            type: live_1.OpType.UpdateObject,
+            data: {},
+        };
+        for (const key in overrides) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
+            const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+            if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                reverseOps.push(...oldValue._serialize(this._id, key));
+                oldValue._detach();
+            }
+            else if (oldValue === undefined) {
+                reverseOps.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+            }
+            else {
+                reverseUpdateOp.data[key] = oldValue;
+            }
+            const newValue = overrides[key];
+            if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                newValue._setParentLink(this, key);
+                newValue._attach(this._doc.generateId(), this._doc);
+                ops.push(...newValue._serialize(this._id, key));
+            }
+            else {
+                updatedProps[key] = newValue;
+            }
+            __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+        }
+        if (Object.keys(reverseUpdateOp.data).length !== 0) {
+            reverseOps.unshift(reverseUpdateOp);
+        }
+        if (Object.keys(updatedProps).length !== 0) {
+            ops.unshift({
+                opId,
+                id: this._id,
+                type: live_1.OpType.UpdateObject,
+                data: updatedProps,
+            });
+        }
+        this._doc.dispatch(ops, reverseOps, [this]);
+    }
+}
+exports.LiveObject = LiveObject;
+_LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _LiveObject_instances = new WeakSet(), _LiveObject_applyUpdate = function _LiveObject_applyUpdate(op) {
+    let isModified = false;
+    const reverse = [];
+    const reverseUpdate = {
+        type: live_1.OpType.UpdateObject,
+        id: this._id,
+        data: {},
+    };
+    reverse.push(reverseUpdate);
+    for (const key in op.data) {
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+            reverse.push(...oldValue._serialize(this._id, key));
+            oldValue._detach();
+        }
+        else if (oldValue !== undefined) {
+            reverseUpdate.data[key] = oldValue;
+        }
+        else if (oldValue === undefined) {
+            reverse.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+        }
+    }
+    let isLocal = false;
+    if (op.opId == null) {
+        isLocal = true;
+        op.opId = this._doc.generateOpId();
+    }
+    for (const key in op.data) {
+        if (isLocal) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, op.opId);
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) == null) {
+            // Not modified localy so we apply update
+            isModified = true;
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === op.opId) {
+            // Acknowlegment from local operation
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+            continue;
+        }
+        else {
+            // Conflict, ignore remote operation
+            continue;
+        }
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        if ((0, utils_1.isCrdt)(oldValue)) {
+            oldValue._detach();
+        }
+        isModified = true;
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, op.data[key]);
+    }
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+        reverse.unshift(reverseUpdate);
+    }
+    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)) {
+        reverse = oldValue._serialize(this._id, op.key);
+        oldValue._detach();
+    }
+    else if (oldValue !== undefined) {
+        reverse = [
+            {
+                type: live_1.OpType.UpdateObject,
+                id: this._id,
+                data: { [key]: oldValue },
+            },
+        ];
+    }
+    __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+    return { modified: this, reverse };
+};

package/lib/cjs/LiveRegister.d.ts

@@ -0,0 +1,21 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { SerializedCrdtWithId, Op } from "./live";
+/**
+ * INTERNAL
+ */
+export declare class LiveRegister<TValue = any> extends AbstractCrdt {
+    #private;
+    constructor(data: TValue);
+    get data(): TValue;
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveRegister<any>;
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId: string, parentKey: string): Op[];
+    _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    _detachChild(crdt: AbstractCrdt): void;
+    _apply(op: Op): ApplyResult;
+}

package/lib/cjs/LiveRegister.js

@@ -0,0 +1,69 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LiveRegister_data;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveRegister = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const live_1 = require("./live");
+/**
+ * INTERNAL
+ */
+class LiveRegister extends AbstractCrdt_1.AbstractCrdt {
+    constructor(data) {
+        super();
+        _LiveRegister_data.set(this, void 0);
+        __classPrivateFieldSet(this, _LiveRegister_data, data, "f");
+    }
+    get data() {
+        return __classPrivateFieldGet(this, _LiveRegister_data, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Register) {
+            throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
+        }
+        const register = new LiveRegister(item.data);
+        register._attach(id, doc);
+        return register;
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null || parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize register if parentId or parentKey is undefined");
+        }
+        return [
+            {
+                type: live_1.OpType.CreateRegister,
+                id: this._id,
+                parentId,
+                parentKey,
+                data: this.data,
+            },
+        ];
+    }
+    _attachChild(id, key, crdt) {
+        throw new Error("Method not implemented.");
+    }
+    _detachChild(crdt) {
+        throw new Error("Method not implemented.");
+    }
+    _apply(op) {
+        return super._apply(op);
+    }
+}
+exports.LiveRegister = LiveRegister;
+_LiveRegister_data = new WeakMap();

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/index.d.ts

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