@liveblocks/client 0.16.4-beta2 → 0.16.4

package/index.mjs

@@ -1,5 +1,5 @@
-import { A as AbstractCrdt, r as remove, S as ServerMessageType, m as mergeStorageUpdates, W as WebsocketCloseCodes, C as ClientMessageType, i as isTokenValid, a as isSameNodeOrChildOf, L as LiveObject, g as getTreesDiffOperations, O as OpType, b as LiveList, p as parseJson, c as isJsonArray, d as compact, e as isJsonObject, f as LiveMap, h as LiveRegister, j as findNonSerializableValue } from './shared.mjs';
-export { b as LiveList, f as LiveMap, L as LiveObject } from './shared.mjs';
+import { A as AbstractCrdt, r as remove, S as ServerMessageType, m as mergeStorageUpdates, W as WebsocketCloseCodes, C as ClientMessageType, i as isTokenValid, a as isSameNodeOrChildOf, L as LiveObject, g as getTreesDiffOperations, O as OpType, b as LiveList, p as parseJson, c as isJsonArray, d as compact, e as isJsonObject, f as deprecateIf } from './shared.mjs';
+export { b as LiveList, h as LiveMap, L as LiveObject } from './shared.mjs';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -1006,7 +1006,7 @@ See v0.13 release notes for more information.
         },
     };
 }
-function defaultState(me, defaultStorageRoot) {
+function defaultState(initialPresence, initialStorage) {
     return {
         connection: { state: "closed" },
         token: null,
@@ -1028,17 +1028,17 @@ function defaultState(me, defaultStorageRoot) {
             pongTimeout: 0,
         },
         buffer: {
-            presence: me == null ? {} : me,
+            presence: initialPresence == null ? {} : initialPresence,
             messages: [],
             storageOperations: [],
         },
         intervalHandles: {
             heartbeat: 0,
         },
-        me: me == null ? {} : me,
+        me: initialPresence == null ? {} : initialPresence,
         users: {},
         others: makeOthers({}),
-        defaultStorageRoot,
+        defaultStorageRoot: initialStorage,
         idFactory: null,
         // Storage
         clock: 0,
@@ -1063,7 +1063,14 @@ function defaultState(me, defaultStorageRoot) {
     };
 }
 function createRoom(options, context) {
-    const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
+    var _a, _b;
+    const initialPresence = (_a = options.initialPresence) !== null && _a !== void 0 ? _a : options.defaultPresence;
+    const initialStorage = (_b = options.initialStorage) !== null && _b !== void 0 ? _b : options.defaultStorageRoot;
+    const state = defaultState(typeof initialPresence === "function"
+        ? initialPresence(context.roomId)
+        : initialPresence, typeof initialStorage === "function"
+        ? initialStorage(context.roomId)
+        : initialStorage);
     const machine = makeStateMachine(state, context);
     const room = {
         id: context.roomId,
@@ -1229,9 +1236,13 @@ function createClient(options) {
         if (internalRoom) {
             return internalRoom.room;
         }
+        deprecateIf(options.defaultPresence, "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP", "defaultPresence");
+        deprecateIf(options.defaultStorageRoot, "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP", "defaultStorageRoot");
         internalRoom = createRoom({
+            initialPresence: options.initialPresence,
+            initialStorage: options.initialStorage,
             defaultPresence: options.defaultPresence,
-            defaultStorageRoot: options.defaultStorageRoot,
+            defaultStorageRoot: options.defaultStorageRoot, // Will get removed in 0.18
         }, {
             roomId,
             throttleDelay,
@@ -1310,332 +1321,4 @@ function prepareAuthentication(clientOptions) {
     throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
 }
 
-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) });
-    }
-}
-
-/**
- * @internal
- */
-const internals = {
-    liveObjectToJson,
-    lsonToJson,
-    patchLiveList,
-    patchImmutableObject,
-    patchLiveObject,
-    patchLiveObjectKey,
-};
-
-export { createClient, internals };
+export { createClient };

package/internal.d.ts

@@ -1,5 +1,5 @@
-import { J as Json, P as Presence, d as JsonObject } from './shared';
-export { g as Resolve } from './shared';
+import { J as Json, P as Presence, d as JsonObject, e as Lson, A as AbstractCrdt, f as LsonObject, L as LiveObject, S as StorageUpdate } from './shared';
+export { g as Resolve, h as RoomInitializers } from './shared';
 
 /**
  * Messages that can be sent from the server to the client.
@@ -121,32 +121,12 @@ declare type UpdateStorageMessage = {
     type: ServerMessageType.UpdateStorage;
     ops: Op[];
 };
-/**
- * Messages that can be sent from the client to the server.
- */
-declare type ClientMessage = ClientEventMessage | UpdatePresenceClientMessage | UpdateStorageClientMessage | FetchStorageClientMessage;
 declare enum ClientMessageType {
     UpdatePresence = 100,
     ClientEvent = 103,
     FetchStorage = 200,
     UpdateStorage = 201
 }
-declare type ClientEventMessage = {
-    type: ClientMessageType.ClientEvent;
-    event: Json;
-};
-declare type UpdatePresenceClientMessage = {
-    type: ClientMessageType.UpdatePresence;
-    data: Presence;
-    targetActor?: number;
-};
-declare type UpdateStorageClientMessage = {
-    type: ClientMessageType.UpdateStorage;
-    ops: Op[];
-};
-declare type FetchStorageClientMessage = {
-    type: ClientMessageType.FetchStorage;
-};
 declare enum CrdtType {
     Object = 0,
     List = 1,
@@ -192,7 +172,6 @@ declare enum OpType {
  * only.
  */
 declare type Op = CreateObjectOp | UpdateObjectOp | DeleteCrdtOp | CreateListOp | SetParentKeyOp | DeleteObjectKeyOp | CreateMapOp | CreateRegisterOp;
-declare type CreateOp = CreateObjectOp | CreateRegisterOp | CreateMapOp | CreateListOp;
 declare type UpdateObjectOp = {
     opId?: string;
     id: string;
@@ -250,23 +229,6 @@ declare type DeleteObjectKeyOp = {
     type: OpType.DeleteObjectKey;
     key: string;
 };
-declare enum WebsocketCloseCodes {
-    CLOSE_ABNORMAL = 1006,
-    INVALID_MESSAGE_FORMAT = 4000,
-    NOT_ALLOWED = 4001,
-    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
-    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
-    CLOSE_WITHOUT_RETRY = 4999
-}
-
-declare const min = 32;
-declare const max = 126;
-declare function makePosition(before?: string, after?: string): string;
-declare function posCodes(str: string): number[];
-declare function pos(codes: number[]): string;
-declare function compare(posA: string, posB: string): number;
 
 /**
  * Displays a deprecation warning in the dev console. Only in dev mode, and
@@ -280,4 +242,8 @@ declare function deprecate(message: string, key?: string): void;
  */
 declare function deprecateIf(condition: unknown, message: string, key?: string): void;
 
-export { ClientEventMessage, ClientMessage, ClientMessageType, CrdtType, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, DeleteCrdtOp, DeleteObjectKeyOp, EventMessage, FetchStorageClientMessage, InitialDocumentStateMessage, Op, OpType, RoomStateMessage, SerializedCrdt, SerializedCrdtWithId, SerializedList, SerializedMap, SerializedObject, SerializedRegister, ServerMessage, ServerMessageType, SetParentKeyOp, UpdateObjectOp, UpdatePresenceClientMessage, UpdatePresenceMessage, UpdateStorageClientMessage, UpdateStorageMessage, UserJoinMessage, UserLeftMessage, WebsocketCloseCodes, compare, deprecate, deprecateIf, makePosition, max, min, pos, posCodes };
+declare function lsonToJson(value: Lson | AbstractCrdt): Json;
+declare function patchLiveObjectKey<O extends LsonObject>(liveObject: LiveObject<O>, key: keyof O, prev: unknown, next: unknown): void;
+declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;
+
+export { ClientMessageType, CrdtType, OpType, SerializedCrdtWithId, ServerMessage, ServerMessageType, deprecate, deprecateIf, lsonToJson, patchImmutableObject, patchLiveObjectKey };