@liveblocks/client 0.15.0-alpha.3 → 0.15.1

package/lib/esm/client.js

@@ -1,119 +0,0 @@
-import { createRoom } from "./room";
-/**
- * Create a client that will be responsible to communicate with liveblocks servers.
- *
- * @example
- * const client = createClient({
- *   authEndpoint: "/api/auth"
- * });
- *
- * // It's also possible to use a function to call your authentication endpoint.
- * // Useful to add additional headers or use an API wrapper (like Firebase functions)
- * const client = createClient({
- *   authEndpoint: async (room) => {
- *     const response = await fetch("/api/auth", {
- *       method: "POST",
- *       headers: {
- *          Authentication: "token",
- *          "Content-Type": "application/json"
- *       },
- *       body: JSON.stringify({ room })
- *     });
- *
- *     return await response.json();
- *   }
- * });
- */
-export function createClient(options) {
-    const clientOptions = options;
-    const throttleDelay = getThrottleDelayFromOptions(options);
-    const rooms = new Map();
-    function getRoom(roomId) {
-        const internalRoom = rooms.get(roomId);
-        return internalRoom ? internalRoom.room : null;
-    }
-    function enter(roomId, options = {}) {
-        let internalRoom = rooms.get(roomId);
-        if (internalRoom) {
-            return internalRoom.room;
-        }
-        internalRoom = createRoom({
-            defaultPresence: options.defaultPresence,
-            defaultStorageRoot: options.defaultStorageRoot,
-        }, {
-            room: roomId,
-            throttleDelay,
-            WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-            fetchPolyfill: clientOptions.fetchPolyfill,
-            liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
-            authentication: prepareAuthentication(clientOptions),
-        });
-        rooms.set(roomId, internalRoom);
-        if (!options.DO_NOT_USE_withoutConnecting) {
-            internalRoom.connect();
-        }
-        return internalRoom.room;
-    }
-    function leave(roomId) {
-        let room = rooms.get(roomId);
-        if (room) {
-            room.disconnect();
-            rooms.delete(roomId);
-        }
-    }
-    if (typeof window !== "undefined") {
-        // TODO: Expose a way to clear these
-        window.addEventListener("online", () => {
-            for (const [, room] of rooms) {
-                room.onNavigatorOnline();
-            }
-        });
-    }
-    if (typeof document !== "undefined") {
-        document.addEventListener("visibilitychange", () => {
-            for (const [, room] of rooms) {
-                room.onVisibilityChange(document.visibilityState);
-            }
-        });
-    }
-    return {
-        getRoom,
-        enter,
-        leave,
-    };
-}
-function getThrottleDelayFromOptions(options) {
-    if (options.throttle === undefined) {
-        return 100;
-    }
-    if (typeof options.throttle !== "number" ||
-        options.throttle < 80 ||
-        options.throttle > 1000) {
-        throw new Error("throttle should be a number between 80 and 1000.");
-    }
-    return options.throttle;
-}
-function prepareAuthentication(clientOptions) {
-    // TODO: throw descriptive errors for invalid options
-    if (typeof clientOptions.publicApiKey === "string") {
-        return {
-            type: "public",
-            publicApiKey: clientOptions.publicApiKey,
-            url: clientOptions.publicAuthorizeEndpoint ||
-                "https://liveblocks.io/api/public/authorize",
-        };
-    }
-    else if (typeof clientOptions.authEndpoint === "string") {
-        return {
-            type: "private",
-            url: clientOptions.authEndpoint,
-        };
-    }
-    else if (typeof clientOptions.authEndpoint === "function") {
-        return {
-            type: "custom",
-            callback: clientOptions.authEndpoint,
-        };
-    }
-    throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
-}

package/lib/esm/immutable.d.ts

@@ -1,9 +0,0 @@
-import { LiveList } from "./LiveList";
-import { LiveObject } from "./LiveObject";
-import { StorageUpdate } from "./types";
-export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
-export declare function liveNodeToJson(value: any): any;
-export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
-export declare function patchLiveObjectKey<T>(liveObject: LiveObject<T>, key: keyof T, prev: any, next: any): 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/esm/immutable.js

@@ -1,290 +0,0 @@
-import { LiveList } from "./LiveList";
-import { LiveMap } from "./LiveMap";
-import { LiveObject } from "./LiveObject";
-import { LiveRegister } from "./LiveRegister";
-import { findNonSerializableValue } from "./utils";
-export function liveObjectToJson(liveObject) {
-    const result = {};
-    const obj = liveObject.toObject();
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-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);
-}
-export function liveNodeToJson(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;
-    }
-    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(obj.map(anyToCrdt));
-    }
-    if (isPlainObject(obj)) {
-        const init = {};
-        for (const key in obj) {
-            init[key] = anyToCrdt(obj[key]);
-        }
-        return new LiveObject(init);
-    }
-    return obj;
-}
-export 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.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++;
-        }
-    }
-}
-export 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));
-    }
-}
-export 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;
-}
-export 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");
-                }
-                let newState = Object.assign({}, state);
-                for (const key in update.updates) {
-                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
-                        newState[key] = liveNodeToJson(update.node.get(key));
-                    }
-                    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 === "insert") {
-                        if (listUpdate.index === newState.length) {
-                            newState.push(liveNodeToJson(listUpdate.item));
-                        }
-                        else {
-                            newState = [
-                                ...newState.slice(0, listUpdate.index),
-                                liveNodeToJson(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),
-                                liveNodeToJson(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),
-                                liveNodeToJson(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");
-                }
-                let 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] = liveNodeToJson(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) });
-    }
-}

package/lib/esm/index.d.ts

@@ -1,6 +0,0 @@
-export { LiveObject } from "./LiveObject";
-export { LiveMap } from "./LiveMap";
-export { LiveList } from "./LiveList";
-export type { Others, Presence, Room, Client, User, BroadcastOptions, } from "./types";
-export { createClient } from "./client";
-export { liveObjectToJson, liveNodeToJson, patchLiveList, patchImmutableObject, patchLiveObject, patchLiveObjectKey, } from "./immutable";

package/lib/esm/live.js

@@ -1,46 +0,0 @@
-export var ServerMessageType;
-(function (ServerMessageType) {
-    ServerMessageType[ServerMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-    ServerMessageType[ServerMessageType["UserJoined"] = 101] = "UserJoined";
-    ServerMessageType[ServerMessageType["UserLeft"] = 102] = "UserLeft";
-    ServerMessageType[ServerMessageType["Event"] = 103] = "Event";
-    ServerMessageType[ServerMessageType["RoomState"] = 104] = "RoomState";
-    ServerMessageType[ServerMessageType["InitialStorageState"] = 200] = "InitialStorageState";
-    ServerMessageType[ServerMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(ServerMessageType || (ServerMessageType = {}));
-export var ClientMessageType;
-(function (ClientMessageType) {
-    ClientMessageType[ClientMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-    ClientMessageType[ClientMessageType["ClientEvent"] = 103] = "ClientEvent";
-    ClientMessageType[ClientMessageType["FetchStorage"] = 200] = "FetchStorage";
-    ClientMessageType[ClientMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(ClientMessageType || (ClientMessageType = {}));
-export var CrdtType;
-(function (CrdtType) {
-    CrdtType[CrdtType["Object"] = 0] = "Object";
-    CrdtType[CrdtType["List"] = 1] = "List";
-    CrdtType[CrdtType["Map"] = 2] = "Map";
-    CrdtType[CrdtType["Register"] = 3] = "Register";
-})(CrdtType || (CrdtType = {}));
-export var OpType;
-(function (OpType) {
-    OpType[OpType["Init"] = 0] = "Init";
-    OpType[OpType["SetParentKey"] = 1] = "SetParentKey";
-    OpType[OpType["CreateList"] = 2] = "CreateList";
-    OpType[OpType["UpdateObject"] = 3] = "UpdateObject";
-    OpType[OpType["CreateObject"] = 4] = "CreateObject";
-    OpType[OpType["DeleteCrdt"] = 5] = "DeleteCrdt";
-    OpType[OpType["DeleteObjectKey"] = 6] = "DeleteObjectKey";
-    OpType[OpType["CreateMap"] = 7] = "CreateMap";
-    OpType[OpType["CreateRegister"] = 8] = "CreateRegister";
-})(OpType || (OpType = {}));
-export var WebsocketCloseCodes;
-(function (WebsocketCloseCodes) {
-    WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-    WebsocketCloseCodes[WebsocketCloseCodes["INVALID_MESSAGE_FORMAT"] = 4000] = "INVALID_MESSAGE_FORMAT";
-    WebsocketCloseCodes[WebsocketCloseCodes["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-})(WebsocketCloseCodes || (WebsocketCloseCodes = {}));

package/lib/esm/position.d.ts

@@ -1,6 +0,0 @@
-export declare const min = 32;
-export declare const max = 126;
-export declare function makePosition(before?: string, after?: string): string;
-export declare function posCodes(str: string): number[];
-export declare function pos(codes: number[]): string;
-export declare function compare(posA: string, posB: string): number;

package/lib/esm/position.js

@@ -1,106 +0,0 @@
-export const min = 32;
-export const max = 126;
-export function makePosition(before, after) {
-    // No children
-    if (before == null && after == null) {
-        return pos([min + 1]);
-    }
-    // Insert at the end
-    if (before != null && after == null) {
-        return getNextPosition(before);
-    }
-    // Insert at the start
-    if (before == null && after != null) {
-        return getPreviousPosition(after);
-    }
-    return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
-}
-function getPreviousPosition(after) {
-    const result = [];
-    const afterCodes = posCodes(after);
-    for (let i = 0; i < afterCodes.length; i++) {
-        const code = afterCodes[i];
-        if (code <= min + 1) {
-            result.push(min);
-            if (afterCodes.length - 1 === i) {
-                result.push(max);
-                break;
-            }
-        }
-        else {
-            result.push(code - 1);
-            break;
-        }
-    }
-    return pos(result);
-}
-function getNextPosition(before) {
-    const result = [];
-    const beforeCodes = posCodes(before);
-    for (let i = 0; i < beforeCodes.length; i++) {
-        const code = beforeCodes[i];
-        if (code === max) {
-            result.push(code);
-            if (beforeCodes.length - 1 === i) {
-                result.push(min + 1);
-                break;
-            }
-        }
-        else {
-            result.push(code + 1);
-            break;
-        }
-    }
-    return pos(result);
-}
-function makePositionFromCodes(before, after) {
-    let index = 0;
-    const result = [];
-    while (true) {
-        const beforeDigit = before[index] || min;
-        const afterDigit = after[index] || max;
-        if (beforeDigit > afterDigit) {
-            throw new Error(`Impossible to generate position between ${before} and ${after}`);
-        }
-        if (beforeDigit === afterDigit) {
-            result.push(beforeDigit);
-            index++;
-            continue;
-        }
-        if (afterDigit - beforeDigit === 1) {
-            result.push(beforeDigit);
-            result.push(...makePositionFromCodes(before.slice(index + 1), []));
-            break;
-        }
-        const mid = (afterDigit + beforeDigit) >> 1;
-        result.push(mid);
-        break;
-    }
-    return result;
-}
-export function posCodes(str) {
-    const codes = [];
-    for (let i = 0; i < str.length; i++) {
-        codes.push(str.charCodeAt(i));
-    }
-    return codes;
-}
-export function pos(codes) {
-    return String.fromCharCode(...codes);
-}
-export function compare(posA, posB) {
-    const aCodes = posCodes(posA);
-    const bCodes = posCodes(posB);
-    const maxLength = Math.max(aCodes.length, bCodes.length);
-    for (let i = 0; i < maxLength; i++) {
-        const a = aCodes[i] == null ? min : aCodes[i];
-        const b = bCodes[i] == null ? min : bCodes[i];
-        if (a === b) {
-            continue;
-        }
-        else {
-            return a - b;
-        }
-    }
-    throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
-}