@liveblocks/client 0.16.4 → 0.16.7

package/internal.mjs

@@ -1,320 +1,148 @@
-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';
+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, o as CrdtType, O as OpType, S as ServerMessageType, W as WebsocketCloseCodes, q as comparePosition, l as deprecate, f as deprecateIf, n as errorIf, s as makePosition, t as throwUsageError } 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;
+ const result = {};
+ for (const key in obj) {
+  const val = obj[key];
+  void 0 !== val && (result[key] = lsonToJson(val));
+ }
+ return result;
 }
+
 function lsonListToJson(value) {
-    return value.map(lsonToJson);
-}
-function liveListToJson(value) {
-    return lsonListToJson(value.toArray());
+ return value.map(lsonToJson);
 }
+
 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;
+ if (value instanceof LiveObject) return lsonObjectToJson(value.toObject());
+ if (value instanceof LiveList) return function(value) {
+  return lsonListToJson(value.toArray());
+ }(value);
+ if (value instanceof LiveMap) return function(map) {
+  const result = {};
+  for (const [key, value] of map.entries()) result[key] = lsonToJson(value);
+  return result;
+ }(value);
+ if (value instanceof LiveRegister) return value.data;
+ if (value instanceof AbstractCrdt) throw new Error("Unhandled subclass of AbstractCrdt encountered");
+ return Array.isArray(value) ? lsonListToJson(value) : isPlainObject(value) ? lsonObjectToJson(value) : value;
 }
+
 function isPlainObject(obj) {
-    return (obj !== null && Object.prototype.toString.call(obj) === "[object Object]");
+ return null !== obj && "[object Object]" === Object.prototype.toString.call(obj);
 }
+
 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++;
-        }
-    }
+ if (null == obj) 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 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));
-    }
+ if ("production" !== process.env.NODE_ENV) {
+  const nonSerializableValue = findNonSerializableValue(next);
+  if (nonSerializableValue) return void console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
+ }
+ const value = liveObject.get(key);
+ if (void 0 === next) liveObject.delete(key); else if (void 0 === value) liveObject.set(key, anyToCrdt(next)); else {
+  if (prev === next) return;
+  value instanceof LiveList && Array.isArray(prev) && Array.isArray(next) ? function(liveList, prev, next) {
+   let i = 0, prevEnd = prev.length - 1, nextEnd = next.length - 1, prevNode = prev[0], nextNode = next[0];
+   outer: {
+    for (;prevNode === nextNode; ) {
+     if (++i, i > prevEnd || i > nextEnd) break outer;
+     prevNode = prev[i], nextNode = next[i];
+    }
+    for (prevNode = prev[prevEnd], nextNode = next[nextEnd]; prevNode === nextNode; ) {
+     if (prevEnd--, nextEnd--, i > prevEnd || i > nextEnd) break outer;
+     prevNode = prev[prevEnd], nextNode = next[nextEnd];
+    }
+   }
+   if (i > prevEnd) {
+    if (i <= nextEnd) for (;i <= nextEnd; ) liveList.insert(anyToCrdt(next[i]), i), 
+    i++;
+   } else if (i > nextEnd) {
+    let localI = i;
+    for (;localI <= prevEnd; ) liveList.delete(i), localI++;
+   } else {
+    for (;i <= prevEnd && i <= nextEnd; ) {
+     prevNode = prev[i], nextNode = next[i];
+     const liveListNode = liveList.get(i);
+     liveListNode instanceof LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode) ? patchLiveObject(liveListNode, prevNode, nextNode) : liveList.set(i, anyToCrdt(nextNode)), 
+     i++;
+    }
+    for (;i <= nextEnd; ) liveList.insert(anyToCrdt(next[i]), i), i++;
+    let localI = i;
+    for (;localI <= prevEnd; ) liveList.delete(i), localI++;
+   }
+  }(value, prev, next) : value instanceof LiveObject && isPlainObject(prev) && isPlainObject(next) ? patchLiveObject(value, prev, next) : 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;
+ const updates = {};
+ for (const key in next) patchLiveObjectKey(root, key, prev[key], next[key]);
+ for (const key in prev) void 0 === next[key] && root.delete(key);
+ Object.keys(updates).length > 0 && root.update(updates);
 }
+
 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);
+ return updates.reduce(((state, update) => function(state, update) {
+  const path = function(node) {
+   const path = [];
+   for (;null != node._parentKey && null != node._parent; ) node._parent instanceof LiveList ? path.push(node._parent._indexOfPosition(node._parentKey)) : path.push(node._parentKey), 
+   node = node._parent;
+   return path;
+  }(update.node);
+  return patchImmutableNode(state, path, update);
+ }(state, update)), state);
 }
+
 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) });
-    }
+ var _a, _b, _c, _d;
+ const pathItem = path.pop();
+ if (void 0 === pathItem) switch (update.type) {
+ case "LiveObject":
+  {
+   if ("object" != typeof state) 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 ("update" === (null === (_a = update.updates[key]) || void 0 === _a ? void 0 : _a.type)) {
+    const val = update.node.get(key);
+    void 0 !== val && (newState[key] = lsonToJson(val));
+   } else "delete" === (null === (_b = update.updates[key]) || void 0 === _b ? void 0 : _b.type) && delete newState[key];
+   return newState;
+  }
+
+ case "LiveList":
+  {
+   if (!1 === Array.isArray(state)) 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) "set" === listUpdate.type ? newState = newState.map(((item, index) => index === listUpdate.index ? listUpdate.item : item)) : "insert" === listUpdate.type ? listUpdate.index === newState.length ? newState.push(lsonToJson(listUpdate.item)) : newState = [ ...newState.slice(0, listUpdate.index), lsonToJson(listUpdate.item), ...newState.slice(listUpdate.index) ] : "delete" === listUpdate.type ? newState.splice(listUpdate.index, 1) : "move" === listUpdate.type && (newState = listUpdate.previousIndex > listUpdate.index ? [ ...newState.slice(0, listUpdate.index), lsonToJson(listUpdate.item), ...newState.slice(listUpdate.index, listUpdate.previousIndex), ...newState.slice(listUpdate.previousIndex + 1) ] : [ ...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 ("object" != typeof state) 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) "update" === (null === (_c = update.updates[key]) || void 0 === _c ? void 0 : _c.type) ? newState[key] = lsonToJson(update.node.get(key)) : "delete" === (null === (_d = update.updates[key]) || void 0 === _d ? void 0 : _d.type) && delete newState[key];
+   return newState;
+  }
+ }
+ if (Array.isArray(state)) {
+  const newArray = [ ...state ];
+  return newArray[pathItem] = patchImmutableNode(state[pathItem], path, update), newArray;
+ }
+ return Object.assign(Object.assign({}, state), {
+  [pathItem]: patchImmutableNode(state[pathItem], path, update)
+ });
 }
 
 export { lsonToJson, patchImmutableObject, patchLiveObjectKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/client",
-  "version": "0.16.4",
+  "version": "0.16.7",
   "description": "A client that lets you interact with Liveblocks servers.",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -31,17 +31,16 @@
   },
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "format": "eslint --fix src/ test/ && prettier --write src/ test/",
     "lint": "eslint src/ test/",
     "test": "jest --watch",
     "test-ci": "jest"
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@babel/core": "^7.12.16",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-proposal-private-methods": "^7.16.11",
-    "@babel/preset-env": "^7.12.16",
-    "@babel/preset-typescript": "^7.12.16",
+    "@babel/core": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/preset-typescript": "^7.16.7",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-node-resolve": "^13.1.3",
     "@rollup/plugin-replace": "^4.0.0",
@@ -51,8 +50,9 @@
     "@types/ws": "^8.2.2",
     "@typescript-eslint/eslint-plugin": "^5.17.0",
     "@typescript-eslint/parser": "^5.17.0",
-    "babel-jest": "^26.6.3",
     "eslint": "^8.12.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "jest": "^26.6.3",
     "jest-each": "^27.5.1",
     "msw": "^0.39.1",
@@ -60,6 +60,7 @@
     "rollup": "^2.68.0",
     "rollup-plugin-command": "^1.1.3",
     "rollup-plugin-dts": "^4.1.0",
+    "rollup-plugin-terser": "^7.0.2",
     "typescript": "^4.4.0",
     "whatwg-fetch": "^3.6.2",
     "ws": "^8.5.0"

package/shared.d.ts

@@ -22,7 +22,11 @@ declare type JsonObject = {
  */
 declare class LiveMap<TKey extends string = string, TValue extends Lson = Lson> extends AbstractCrdt {
     private _map;
-    constructor(entries?: readonly (readonly [TKey, TValue])[] | null | undefined);
+    constructor(entries?: readonly (readonly [TKey, TValue])[] | undefined);
+    /**
+     * @deprecated Please call as `new LiveMap()` or `new LiveMap([])` instead.
+     */
+    constructor(entries: null);
     /**
      * Returns a specified element from the LiveMap.
      * @param key The key of the element to return.
@@ -394,7 +398,15 @@ declare type ClientOptions = {
     publicApiKey?: never;
     authEndpoint: AuthEndpoint;
 });
-declare type ConnectionState = "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
+declare type Connection = {
+    state: "closed" | "authenticating" | "unavailable" | "failed";
+} | {
+    state: "open" | "connecting";
+    id: number;
+    userId?: string;
+    userInfo?: any;
+};
+declare type ConnectionState = Connection["state"];
 declare type OthersEvent<T extends Presence = Presence> = {
     type: "leave";
     user: User<T>;
@@ -738,7 +750,7 @@ declare abstract class AbstractCrdt {
 declare class LiveObject<O extends LsonObject = LsonObject> extends AbstractCrdt {
     private _map;
     private _propToLastUpdate;
-    constructor(object?: O);
+    constructor(obj?: O);
     private _applyUpdate;
     private _applyDeleteObjectKey;
     /**