@liveblocks/client 0.16.3 → 0.16.4

package/internal.mjs

@@ -0,0 +1,320 @@
+import { L as LiveObject, b as LiveList, h as LiveMap, j as LiveRegister, A as AbstractCrdt, k as findNonSerializableValue } from './shared.mjs';
+export { C as ClientMessageType, l as CrdtType, O as OpType, S as ServerMessageType, n as deprecate, f as deprecateIf } from './shared.mjs';
+
+function lsonObjectToJson(obj) {
+    const result = {};
+    for (const key in obj) {
+        const val = obj[key];
+        if (val !== undefined) {
+            result[key] = lsonToJson(val);
+        }
+    }
+    return result;
+}
+function liveObjectToJson(liveObject) {
+    return lsonObjectToJson(liveObject.toObject());
+}
+function liveMapToJson(map) {
+    const result = {};
+    for (const [key, value] of map.entries()) {
+        result[key] = lsonToJson(value);
+    }
+    return result;
+}
+function lsonListToJson(value) {
+    return value.map(lsonToJson);
+}
+function liveListToJson(value) {
+    return lsonListToJson(value.toArray());
+}
+function lsonToJson(value) {
+    //                                     ^^^^^^^^^^^^
+    //                                     FIXME: Remove me later. This requires the
+    //                                     addition of a concrete LiveStructure type first.
+    // Check for LiveStructure datastructures first
+    if (value instanceof LiveObject) {
+        return liveObjectToJson(value);
+    }
+    else if (value instanceof LiveList) {
+        return liveListToJson(value);
+    }
+    else if (value instanceof LiveMap) {
+        return liveMapToJson(value);
+    }
+    else if (value instanceof LiveRegister) {
+        return value.data;
+    }
+    else if (value instanceof AbstractCrdt) {
+        // This code path should never be taken
+        throw new Error("Unhandled subclass of AbstractCrdt encountered");
+    }
+    // Then for composite Lson values
+    if (Array.isArray(value)) {
+        return lsonListToJson(value);
+    }
+    else if (isPlainObject(value)) {
+        return lsonObjectToJson(value);
+    }
+    // Finally, if value is an LsonScalar, then it's also a valid JsonScalar
+    return value;
+}
+function isPlainObject(obj) {
+    return (obj !== null && Object.prototype.toString.call(obj) === "[object Object]");
+}
+function anyToCrdt(obj) {
+    //                              ^^^ AbstractCrdt?
+    if (obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return new LiveList(obj.map(anyToCrdt));
+    }
+    if (isPlainObject(obj)) {
+        const init = {};
+        for (const key in obj) {
+            init[key] = anyToCrdt(obj[key]);
+        }
+        return new 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) {
+        let localI = i;
+        while (localI <= prevEnd) {
+            liveList.delete(i);
+            localI++;
+        }
+    }
+    else {
+        while (i <= prevEnd && i <= nextEnd) {
+            prevNode = prev[i];
+            nextNode = next[i];
+            const liveListNode = liveList.get(i);
+            if (liveListNode instanceof LiveObject &&
+                isPlainObject(prevNode) &&
+                isPlainObject(nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            }
+            else {
+                liveList.set(i, anyToCrdt(nextNode));
+            }
+            i++;
+        }
+        while (i <= nextEnd) {
+            liveList.insert(anyToCrdt(next[i]), i);
+            i++;
+        }
+        let localI = i;
+        while (localI <= prevEnd) {
+            liveList.delete(i);
+            localI++;
+        }
+    }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+    if (process.env.NODE_ENV !== "production") {
+        const nonSerializableValue = findNonSerializableValue(next);
+        if (nonSerializableValue) {
+            console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
+            return;
+        }
+    }
+    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 &&
+        Array.isArray(prev) &&
+        Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    }
+    else if (value instanceof LiveObject &&
+        isPlainObject(prev) &&
+        isPlainObject(next)) {
+        patchLiveObject(value, prev, next);
+    }
+    else {
+        liveObject.set(key, anyToCrdt(next));
+    }
+}
+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);
+    }
+}
+function getParentsPath(node) {
+    const path = [];
+    while (node._parentKey != null && node._parent != null) {
+        if (node._parent instanceof 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);
+}
+function patchImmutableObjectWithUpdate(state, update) {
+    const path = getParentsPath(update.node);
+    return patchImmutableNode(state, path, update);
+}
+function patchImmutableNode(state, path, update) {
+    var _a, _b, _c, _d;
+    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");
+                }
+                const newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
+                        const val = update.node.get(key);
+                        if (val !== undefined) {
+                            newState[key] = lsonToJson(val);
+                        }
+                    }
+                    else if (((_b = update.updates[key]) === null || _b === void 0 ? void 0 : _b.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
+            }
+            case "LiveList": {
+                if (Array.isArray(state) === false) {
+                    throw new Error("Internal: received update on LiveList but state was not an array");
+                }
+                let newState = state.map((x) => x);
+                for (const listUpdate of update.updates) {
+                    if (listUpdate.type === "set") {
+                        newState = newState.map((item, index) => index === listUpdate.index ? listUpdate.item : item);
+                    }
+                    else if (listUpdate.type === "insert") {
+                        if (listUpdate.index === newState.length) {
+                            newState.push(lsonToJson(listUpdate.item));
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index),
+                            ];
+                        }
+                    }
+                    else if (listUpdate.type === "delete") {
+                        newState.splice(listUpdate.index, 1);
+                    }
+                    else if (listUpdate.type === "move") {
+                        if (listUpdate.previousIndex > listUpdate.index) {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1),
+                            ];
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index + 1),
+                            ];
+                        }
+                    }
+                }
+                return newState;
+            }
+            case "LiveMap": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveMap but state was not an object");
+                }
+                const newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_c = update.updates[key]) === null || _c === void 0 ? void 0 : _c.type) === "update") {
+                        newState[key] = lsonToJson(update.node.get(key));
+                    }
+                    else if (((_d = update.updates[key]) === null || _d === void 0 ? void 0 : _d.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
+            }
+        }
+    }
+    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) });
+    }
+}
+
+export { lsonToJson, patchImmutableObject, patchLiveObjectKey };

package/package.json

@@ -1,27 +1,25 @@
 {
   "name": "@liveblocks/client",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "A client that lets you interact with Liveblocks servers.",
   "main": "./index.js",
+  "module": "./index.mjs",
   "types": "./index.d.ts",
-  "files": [
-    "**"
-  ],
   "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./index.d.ts",
-      "module": "./esm/index.js",
-      "import": "./esm/index.mjs",
-      "default": "./index.js"
-    },
     "./internal": {
       "types": "./internal.d.ts",
-      "module": "./esm/internal.js",
-      "import": "./esm/internal.mjs",
-      "default": "./internal.js"
+      "require": "./internal.js",
+      "import": "./internal.mjs"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "import": "./index.mjs"
     }
   },
+  "files": [
+    "**"
+  ],
   "keywords": [
     "liveblocks",
     "multiplayer",
@@ -33,6 +31,7 @@
   },
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "lint": "eslint src/ test/",
     "test": "jest --watch",
     "test-ci": "jest"
   },
@@ -45,6 +44,7 @@
     "@babel/preset-typescript": "^7.12.16",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-replace": "^4.0.0",
     "@rollup/plugin-typescript": "^8.3.1",
     "@types/jest": "^26.0.21",
     "@types/node-fetch": "^2.6.1",
@@ -58,8 +58,8 @@
     "msw": "^0.39.1",
     "node-fetch": "2.6.7",
     "rollup": "^2.68.0",
+    "rollup-plugin-command": "^1.1.3",
     "rollup-plugin-dts": "^4.1.0",
-    "rollup-plugin-esbuild": "^4.8.2",
     "typescript": "^4.4.0",
     "whatwg-fetch": "^3.6.2",
     "ws": "^8.5.0"
@@ -68,5 +68,6 @@
     "type": "git",
     "url": "https://github.com/liveblocks/liveblocks.git",
     "directory": "packages/liveblocks-client"
-  }
+  },
+  "sideEffects": false
 }