@liveblocks/client 0.15.0-alpha.3 → 0.15.1

package/lib/esm/types.js

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

package/lib/esm/utils.d.ts

@@ -1,15 +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;
-export declare function findNonSerializableValue(value: any, path?: string): {
-    path: string;
-    value: any;
-} | false;

package/lib/esm/utils.js

@@ -1,213 +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;
-}
-function isPlain(value) {
-    const type = typeof value;
-    return (type === "undefined" ||
-        value === null ||
-        type === "string" ||
-        type === "boolean" ||
-        type === "number" ||
-        Array.isArray(value) ||
-        isPlainObject(value));
-}
-function isPlainObject(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    let proto = Object.getPrototypeOf(value);
-    if (proto === null)
-        return true;
-    let baseProto = proto;
-    while (Object.getPrototypeOf(baseProto) !== null) {
-        baseProto = Object.getPrototypeOf(baseProto);
-    }
-    return proto === baseProto;
-}
-export function findNonSerializableValue(value, path = "") {
-    if (!isPlain) {
-        return {
-            path: path || "root",
-            value: value,
-        };
-    }
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    for (const [key, nestedValue] of Object.entries(value)) {
-        const nestedPath = path ? path + "." + key : key;
-        if (!isPlain(nestedValue)) {
-            return {
-                path: nestedPath,
-                value: nestedValue,
-            };
-        }
-        if (typeof nestedValue === "object") {
-            const nonSerializableNestedValue = findNonSerializableValue(nestedValue, nestedPath);
-            if (nonSerializableNestedValue) {
-                return nonSerializableNestedValue;
-            }
-        }
-    }
-    return false;
-}