@liveblocks/client 0.17.11-debug2 → 0.17.11

package/internal.mjs

@@ -1,364 +1,31 @@
-import {
-  ClientMsgCode,
-  CrdtType,
-  LiveList,
-  LiveMap,
-  LiveObject,
-  LiveRegister,
-  OpCode,
-  ServerMsgCode,
-  WebsocketCloseCodes,
-  assertNever,
-  b64decode,
-  comparePosition,
-  deprecate,
-  deprecateIf,
-  errorIf,
-  findNonSerializableValue,
-  isAppOnlyAuthToken,
-  isAuthToken,
-  isChildCrdt,
-  isJsonArray,
-  isJsonObject,
-  isJsonScalar,
-  isLiveList,
-  isLiveObject,
-  isPlainObject,
-  isRoomAuthToken,
-  isRootCrdt,
-  isScope,
-  makePosition,
-  nn,
-  throwUsageError,
-  tryParseJson
-} from "./chunk-ATVOU6HF.mjs";
+import mod from "./internal.js";
 
-// src/immutable.ts
-function lsonObjectToJson(obj) {
-  const result = {};
-  for (const key in obj) {
-    const val = obj[key];
-    if (val !== void 0) {
-      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) {
-  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;
-  }
-  if (Array.isArray(value)) {
-    return lsonListToJson(value);
-  } else if (isPlainObject(value)) {
-    return lsonObjectToJson(value);
-  }
-  return value;
-}
-function deepLiveify(value) {
-  if (Array.isArray(value)) {
-    return new LiveList(value.map(deepLiveify));
-  } else if (isPlainObject(value)) {
-    const init = {};
-    for (const key in value) {
-      const val = value[key];
-      if (val === void 0) {
-        continue;
-      }
-      init[key] = deepLiveify(val);
-    }
-    return new LiveObject(init);
-  } else {
-    return value;
-  }
-}
-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];
-  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(deepLiveify(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 (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
-        patchLiveObject(liveListNode, prevNode, nextNode);
-      } else {
-        liveList.set(i, deepLiveify(nextNode));
-      }
-      i++;
-    }
-    while (i <= nextEnd) {
-      liveList.insert(deepLiveify(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.
-Only serializable value can be synced with Liveblocks.`
-      );
-      return;
-    }
-  }
-  const value = liveObject.get(key);
-  if (next === void 0) {
-    liveObject.delete(key);
-  } else if (value === void 0) {
-    liveObject.set(key, deepLiveify(next));
-  } else if (prev === next) {
-    return;
-  } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
-    patchLiveList(value, prev, next);
-  } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
-    patchLiveObject(value, prev, next);
-  } else {
-    liveObject.set(key, deepLiveify(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] === void 0) {
-      root.delete(key);
-    }
-  }
-  if (Object.keys(updates).length > 0) {
-    root.update(updates);
-  }
-}
-function getParentsPath(node) {
-  const path = [];
-  while (node.parent.type === "HasParent") {
-    if (isLiveList(node.parent.node)) {
-      path.push(node.parent.node._indexOfPosition(node.parent.key));
-    } else {
-      path.push(node.parent.key);
-    }
-    node = node.parent.node;
-  }
-  return path;
-}
-function patchImmutableObject(state, updates) {
-  return updates.reduce(
-    (state2, update) => patchImmutableObjectWithUpdate(state2, update),
-    state
-  );
-}
-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 === void 0) {
-    switch (update.type) {
-      case "LiveObject": {
-        if (state === null || typeof state !== "object" || Array.isArray(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.updates[key]?.type === "update") {
-            const val = update.node.get(key);
-            if (val !== void 0) {
-              newState[key] = lsonToJson(val);
-            }
-          } else if (update.updates[key]?.type === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-      case "LiveList": {
-        if (!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) {
-          if (listUpdate.type === "set") {
-            newState = newState.map(
-              (item, index) => index === listUpdate.index ? lsonToJson(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 (state === null || typeof state !== "object" || Array.isArray(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) {
-          if (update.updates[key]?.type === "update") {
-            const value = update.node.get(key);
-            if (value !== void 0) {
-              newState[key] = lsonToJson(value);
-            }
-          } else if (update.updates[key]?.type === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-    }
-  }
-  if (Array.isArray(state)) {
-    const newArray = [...state];
-    newArray[pathItem] = patchImmutableNode(
-      state[pathItem],
-      path,
-      update
-    );
-    return newArray;
-  } else if (state !== null && typeof state === "object") {
-    const node = state[pathItem];
-    if (node === void 0) {
-      return state;
-    } else {
-      return {
-        ...state,
-        [pathItem]: patchImmutableNode(node, path, update)
-      };
-    }
-  } else {
-    return state;
-  }
-}
-export {
-  ClientMsgCode,
-  CrdtType,
-  OpCode,
-  ServerMsgCode,
-  WebsocketCloseCodes,
-  assertNever,
-  b64decode,
-  comparePosition,
-  deprecate,
-  deprecateIf,
-  errorIf,
-  isAppOnlyAuthToken,
-  isAuthToken,
-  isChildCrdt,
-  isJsonArray,
-  isJsonObject,
-  isJsonScalar,
-  isPlainObject,
-  isRoomAuthToken,
-  isRootCrdt,
-  isScope,
-  lsonToJson,
-  makePosition,
-  nn,
-  patchImmutableObject,
-  patchLiveObjectKey,
-  throwUsageError,
-  tryParseJson
-};
+export default mod;
+export const ClientMsgCode = mod.ClientMsgCode;
+export const CrdtType = mod.CrdtType;
+export const OpCode = mod.OpCode;
+export const ServerMsgCode = mod.ServerMsgCode;
+export const WebsocketCloseCodes = mod.WebsocketCloseCodes;
+export const assertNever = mod.assertNever;
+export const b64decode = mod.b64decode;
+export const comparePosition = mod.comparePosition;
+export const deprecate = mod.deprecate;
+export const deprecateIf = mod.deprecateIf;
+export const errorIf = mod.errorIf;
+export const isAppOnlyAuthToken = mod.isAppOnlyAuthToken;
+export const isAuthToken = mod.isAuthToken;
+export const isChildCrdt = mod.isChildCrdt;
+export const isJsonArray = mod.isJsonArray;
+export const isJsonObject = mod.isJsonObject;
+export const isJsonScalar = mod.isJsonScalar;
+export const isPlainObject = mod.isPlainObject;
+export const isRoomAuthToken = mod.isRoomAuthToken;
+export const isRootCrdt = mod.isRootCrdt;
+export const isScope = mod.isScope;
+export const lsonToJson = mod.lsonToJson;
+export const makePosition = mod.makePosition;
+export const nn = mod.nn;
+export const patchImmutableObject = mod.patchImmutableObject;
+export const patchLiveObjectKey = mod.patchLiveObjectKey;
+export const throwUsageError = mod.throwUsageError;
+export const tryParseJson = mod.tryParseJson;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/client",
-  "version": "0.17.11-debug2",
+  "version": "0.17.11",
   "description": "A client that lets you interact with Liveblocks servers.",
   "main": "./index.js",
   "module": "./index.mjs",