@liveblocks/client 0.15.0-alpha.2 → 0.15.0

package/lib/esm/types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils.d.ts

@@ -1,11 +0,0 @@
-import { AbstractCrdt, Doc } from "./AbstractCrdt";
-import { SerializedCrdtWithId, Op, SerializedCrdt } from "./live";
-import { StorageUpdate } from "./types";
-export declare function remove<T>(array: T[], item: T): void;
-export declare function isSameNodeOrChildOf(node: AbstractCrdt, parent: AbstractCrdt): boolean;
-export declare function deserialize(entry: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): AbstractCrdt;
-export declare function isCrdt(obj: any): obj is AbstractCrdt;
-export declare function selfOrRegisterValue(obj: AbstractCrdt): any;
-export declare function selfOrRegister(obj: any): AbstractCrdt;
-export declare function getTreesDiffOperations(currentItems: Map<string, SerializedCrdt>, newItems: Map<string, SerializedCrdt>): Op[];
-export declare function mergeStorageUpdates(first: StorageUpdate | undefined, second: StorageUpdate): StorageUpdate;

package/lib/esm/utils.js

@@ -1,164 +0,0 @@
-import { CrdtType, OpType, } from "./live";
-import { LiveList } from "./LiveList";
-import { LiveMap } from "./LiveMap";
-import { LiveObject } from "./LiveObject";
-import { LiveRegister } from "./LiveRegister";
-export function remove(array, item) {
-    for (let i = 0; i < array.length; i++) {
-        if (array[i] === item) {
-            array.splice(i, 1);
-            break;
-        }
-    }
-}
-export function isSameNodeOrChildOf(node, parent) {
-    if (node === parent) {
-        return true;
-    }
-    if (node._parent) {
-        return isSameNodeOrChildOf(node._parent, parent);
-    }
-    return false;
-}
-export function deserialize(entry, parentToChildren, doc) {
-    switch (entry[1].type) {
-        case CrdtType.Object: {
-            return LiveObject._deserialize(entry, parentToChildren, doc);
-        }
-        case CrdtType.List: {
-            return LiveList._deserialize(entry, parentToChildren, doc);
-        }
-        case CrdtType.Map: {
-            return LiveMap._deserialize(entry, parentToChildren, doc);
-        }
-        case CrdtType.Register: {
-            return LiveRegister._deserialize(entry, parentToChildren, doc);
-        }
-        default: {
-            throw new Error("Unexpected CRDT type");
-        }
-    }
-}
-export function isCrdt(obj) {
-    return (obj instanceof LiveObject ||
-        obj instanceof LiveMap ||
-        obj instanceof LiveList ||
-        obj instanceof LiveRegister);
-}
-export function selfOrRegisterValue(obj) {
-    if (obj instanceof LiveRegister) {
-        return obj.data;
-    }
-    return obj;
-}
-export function selfOrRegister(obj) {
-    if (obj instanceof LiveObject ||
-        obj instanceof LiveMap ||
-        obj instanceof LiveList) {
-        return obj;
-    }
-    else if (obj instanceof LiveRegister) {
-        throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
-    }
-    else {
-        return new LiveRegister(obj);
-    }
-}
-export function getTreesDiffOperations(currentItems, newItems) {
-    const ops = [];
-    currentItems.forEach((_, id) => {
-        if (!newItems.get(id)) {
-            // Delete crdt
-            ops.push({
-                type: OpType.DeleteCrdt,
-                id: id,
-            });
-        }
-    });
-    newItems.forEach((crdt, id) => {
-        const currentCrdt = currentItems.get(id);
-        if (currentCrdt) {
-            if (crdt.type === CrdtType.Object) {
-                if (JSON.stringify(crdt.data) !==
-                    JSON.stringify(currentCrdt.data)) {
-                    ops.push({
-                        type: OpType.UpdateObject,
-                        id: id,
-                        data: crdt.data,
-                    });
-                }
-            }
-            if (crdt.parentKey !== currentCrdt.parentKey) {
-                ops.push({
-                    type: OpType.SetParentKey,
-                    id: id,
-                    parentKey: crdt.parentKey,
-                });
-            }
-        }
-        else {
-            // new Crdt
-            switch (crdt.type) {
-                case CrdtType.Register:
-                    ops.push({
-                        type: OpType.CreateRegister,
-                        id: id,
-                        parentId: crdt.parentId,
-                        parentKey: crdt.parentKey,
-                        data: crdt.data,
-                    });
-                    break;
-                case CrdtType.List:
-                    ops.push({
-                        type: OpType.CreateList,
-                        id: id,
-                        parentId: crdt.parentId,
-                        parentKey: crdt.parentKey,
-                    });
-                    break;
-                case CrdtType.Object:
-                    ops.push({
-                        type: OpType.CreateObject,
-                        id: id,
-                        parentId: crdt.parentId,
-                        parentKey: crdt.parentKey,
-                        data: crdt.data,
-                    });
-                    break;
-                case CrdtType.Map:
-                    ops.push({
-                        type: OpType.CreateMap,
-                        id: id,
-                        parentId: crdt.parentId,
-                        parentKey: crdt.parentKey,
-                    });
-                    break;
-            }
-        }
-    });
-    return ops;
-}
-export function mergeStorageUpdates(first, second) {
-    if (!first) {
-        return second;
-    }
-    if (second.type === "LiveObject") {
-        const updates = first.updates;
-        for (const [key, value] of Object.entries(second.updates)) {
-            updates[key] = value;
-        }
-        return Object.assign(Object.assign({}, second), { updates: updates });
-    }
-    else if (second.type === "LiveMap") {
-        const updates = first.updates;
-        for (const [key, value] of Object.entries(second.updates)) {
-            updates[key] = value;
-        }
-        return Object.assign(Object.assign({}, second), { updates: updates });
-    }
-    else if (second.type === "LiveList") {
-        const updates = first.updates;
-        return Object.assign(Object.assign({}, second), { updates: updates.concat(second.updates) });
-    }
-    return second;
-}