@liveblocks/client 0.12.2 → 0.13.1

package/lib/cjs/types.d.ts

@@ -1,4 +1,6 @@
-import { LiveObject } from "./doc";
+import type { LiveList } from "./LiveList";
+import type { LiveMap } from "./LiveMap";
+import type { LiveObject } from "./LiveObject";
 export declare type MyPresenceCallback<T extends Presence = Presence> = (me: T) => void;
 export declare type OthersEventCallback<T extends Presence = Presence> = (others: Others<T>, event: OthersEvent<T>) => void;
 export declare type EventCallback = ({ connectionId, event, }: {
@@ -14,17 +16,31 @@ export declare type RoomEventCallbackMap = {
     error: ErrorCallback;
     connection: ConnectionCallback;
 };
+export declare type LiveMapUpdates<TKey extends string = string, TValue = any> = {
+    type: "LiveMap";
+    node: LiveMap<TKey, TValue>;
+};
+export declare type LiveObjectUpdates<TData = any> = {
+    type: "LiveObject";
+    node: LiveObject<TData>;
+};
+export declare type LiveListUpdates<TItem = any> = {
+    type: "LiveList";
+    node: LiveList<TItem>;
+};
+export declare type StorageUpdate = LiveMapUpdates | LiveObjectUpdates | LiveListUpdates;
+export declare type StorageCallback = (updates: StorageUpdate[]) => void;
 export declare type Client = {
     /**
      * Gets a room. Returns null if {@link Client.enter} has not been called previously.
      *
-     * @param roomId - The id of the room
+     * @param roomId The id of the room
      */
     getRoom(roomId: string): Room | null;
     /**
      * Enters a room and returns it.
-     * @param roomId - The id of the room
-     * @param defaultPresence - Optional. Should be serializable to JSON. If omitted, an empty object will be used.
+     * @param roomId The id of the room
+     * @param defaultPresence Optional. Should be serializable to JSON. If omitted, an empty object will be used.
      */
     enter<TStorageRoot extends Record<string, any> = Record<string, any>>(roomId: string, options?: {
         defaultPresence?: Presence;
@@ -32,7 +48,7 @@ export declare type Client = {
     }): Room;
     /**
      * Leaves a room.
-     * @param roomId - The id of the room
+     * @param roomId The id of the room
      */
     leave(roomId: string): void;
 };
@@ -131,85 +147,224 @@ export declare type Room = {
         /**
          * Subscribe to the current user presence updates.
          *
-         * @param listener - the callback that is called every time the current user presence is updated with {@link Room.updatePresence}.
+         * @param listener the callback that is called every time the current user presence is updated with {@link Room.updatePresence}.
          *
          * @example
          * room.subscribe("my-presence", (presence) => {
          *   // Do something
          * });
          */
-        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): void;
+        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): () => void;
         /**
          * Subscribe to the other users updates.
          *
-         * @param listener - the callback that is called when a user enters or leaves the room or when a user update its presence.
+         * @param listener the callback that is called when a user enters or leaves the room or when a user update its presence.
          *
          * @example
          * room.subscribe("others", (others) => {
          *   // Do something
          * });
          */
-        <T extends Presence>(type: "others", listener: OthersEventCallback<T>): void;
+        <T extends Presence>(type: "others", listener: OthersEventCallback<T>): () => void;
         /**
          * Subscribe to events broadcasted by {@link Room.broadcastEvent}
          *
-         * @param listener - the callback that is called when a user calls {@link Room.broadcastEvent}
+         * @param listener the callback that is called when a user calls {@link Room.broadcastEvent}
          *
          * @example
          * room.subscribe("event", ({ event, connectionId }) => {
          *   // Do something
          * });
          */
-        (type: "event", listener: EventCallback): void;
+        (type: "event", listener: EventCallback): () => void;
         /**
          * Subscribe to errors thrown in the room.
          */
-        (type: "error", listener: ErrorCallback): void;
+        (type: "error", listener: ErrorCallback): () => void;
         /**
          * Subscribe to connection state updates.
          */
-        (type: "connection", listener: ConnectionCallback): void;
-    };
-    unsubscribe: {
+        (type: "connection", listener: ConnectionCallback): () => void;
         /**
-         * Unsubscribe to the current user presence updates.
+         * Subscribes to changes made on a {@link LiveMap}. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveMap}.
          *
-         * @param listener - the callback that has been used with {@link Room.subscribe}("my-presence").
+         * @param listener the callback this called when the {@link LiveMap} changes.
+         *
+         * @returns Unsubscribe function.
          *
          * @example
-         * const onPresenceChange = (presence) => { };
-         * room.subscribe("my-presence", onPresenceChange);
-         * room.unsubscribe("my-presence", onPresenceChange);
+         * const liveMap = new LiveMap();
+         * const unsubscribe = room.subscribe(liveMap, (liveMap) => { });
+         * unsubscribe();
          */
-        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): void;
+        <TKey extends string, TValue>(liveMap: LiveMap<TKey, TValue>, listener: (liveMap: LiveMap<TKey, TValue>) => void): () => void;
         /**
-         * Unsubscribe to the other users updates.
+         * Subscribes to changes made on a {@link LiveObject}. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveObject}.
+         *
+         * @param listener the callback this called when the {@link LiveObject} changes.
          *
-         * @param listener - the callback that has been used with {@link Room.subscribe}("others").
+         * @returns Unsubscribe function.
          *
          * @example
-         * const onOthersChange = (presence) => { };
-         * room.subscribe("others", onOthersChange);
-         * room.unsubscribe("others", onOthersChange);
+         * const liveObject = new LiveObject();
+         * const unsubscribe = room.subscribe(liveObject, (liveObject) => { });
+         * unsubscribe();
          */
-        <T extends Presence>(type: "others", listener: OthersEventCallback<T>): void;
+        <TData>(liveObject: LiveObject<TData>, callback: (liveObject: LiveObject<TData>) => void): () => void;
+        /**
+         * Subscribes to changes made on a {@link LiveList}. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveList}.
+         *
+         * @param listener the callback this called when the {@link LiveList} changes.
+         *
+         * @returns Unsubscribe function.
+         *
+         * @example
+         * const liveList = new LiveList();
+         * const unsubscribe = room.subscribe(liveList, (liveList) => { });
+         * unsubscribe();
+         */
+        <TItem>(liveList: LiveList<TItem>, callback: (liveList: LiveList<TItem>) => void): () => void;
+        /**
+         * Subscribes to changes made on a {@link LiveMap} and all the nested data structures. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveMap}.
+         *
+         * @param listener the callback this called when the {@link LiveMap} changes.
+         *
+         * @returns Unsubscribe function.
+         *
+         * @example
+         * const liveMap = new LiveMap();
+         * const unsubscribe = room.subscribe(liveMap, (liveMap) => { }, { isDeep: true });
+         * unsubscribe();
+         */
+        <TKey extends string, TValue>(liveMap: LiveMap<TKey, TValue>, callback: (updates: StorageUpdate[]) => void, options: {
+            isDeep: true;
+        }): () => void;
         /**
-         * Unsubscribe to events broadcasted by {@link Room.broadcastEvent}
+         * Subscribes to changes made on a {@link LiveObject} and all the nested data structures. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveObject}.
+         *
+         * @param listener the callback this called when the {@link LiveObject} changes.
          *
-         * @param listener - the callback that has been used with {@link Room.unsubscribe}("event").
+         * @returns Unsubscribe function.
          *
          * @example
-         * const onEvent = ({ event, connectionId }) => { };
-         * room.subscribe("event", onEvent);
-         * room.unsubscribe("event", onEvent);
+         * const liveObject = new LiveObject();
+         * const unsubscribe = room.subscribe(liveObject, (liveObject) => { }, { isDeep: true });
+         * unsubscribe();
+         */
+        <TData>(liveObject: LiveObject<TData>, callback: (updates: StorageUpdate[]) => void, options: {
+            isDeep: true;
+        }): () => void;
+        /**
+         * Subscribes to changes made on a {@link LiveList} and all the nested data structures. Returns an unsubscribe function.
+         * In a future version, we will also expose what exactly changed in the {@link LiveList}.
+         *
+         * @param listener the callback this called when the {@link LiveList} changes.
+         *
+         * @returns Unsubscribe function.
+         *
+         * @example
+         * const liveList = new LiveList();
+         * const unsubscribe = room.subscribe(liveList, (liveList) => { }, { isDeep: true });
+         * unsubscribe();
+         */
+        <TItem>(liveList: LiveList<TItem>, callback: (updates: StorageUpdate[]) => void, options: {
+            isDeep: true;
+        }): () => void;
+    };
+    /**
+     * Room's history contains functions that let you undo and redo operation made on by the current client on the presence and storage.
+     */
+    history: {
+        /**
+         * Undoes the last operation executed by the current client.
+         * It does not impact operations made by other clients.
+         *
+         * @example
+         * room.updatePresence({ selectedId: "xxx" }, { addToHistory: true });
+         * room.updatePresence({ selectedId: "yyy" }, { addToHistory: true });
+         * room.history.undo();
+         * // room.getPresence() equals { selectedId: "xxx" }
+         */
+        undo: () => void;
+        /**
+         * Redoes the last operation executed by the current client.
+         * It does not impact operations made by other clients.
+         *
+         * @example
+         * room.updatePresence({ selectedId: "xxx" }, { addToHistory: true });
+         * room.updatePresence({ selectedId: "yyy" }, { addToHistory: true });
+         * room.history.undo();
+         * // room.getPresence() equals { selectedId: "xxx" }
+         * room.history.redo();
+         * // room.getPresence() equals { selectedId: "yyy" }
+         */
+        redo: () => void;
+        /**
+         * All future modifications made on the Room will be merged together to create a single history item until resume is called.
+         *
+         * @example
+         * room.updatePresence({ cursor: { x: 0, y: 0 } }, { addToHistory: true });
+         * room.history.pause();
+         * room.updatePresence({ cursor: { x: 1, y: 1 } }, { addToHistory: true });
+         * room.updatePresence({ cursor: { x: 2, y: 2 } }, { addToHistory: true });
+         * room.history.resume();
+         * room.history.undo();
+         * // room.getPresence() equals { cursor: { x: 0, y: 0 } }
+         */
+        pause: () => void;
+        /**
+         * Resumes history. Modifications made on the Room are not merged into a single history item anymore.
+         *
+         * @example
+         * room.updatePresence({ cursor: { x: 0, y: 0 } }, { addToHistory: true });
+         * room.history.pause();
+         * room.updatePresence({ cursor: { x: 1, y: 1 } }, { addToHistory: true });
+         * room.updatePresence({ cursor: { x: 2, y: 2 } }, { addToHistory: true });
+         * room.history.resume();
+         * room.history.undo();
+         * // room.getPresence() equals { cursor: { x: 0, y: 0 } }
+         */
+        resume: () => void;
+    };
+    /**
+     * @deprecated use the callback returned by subscribe instead.
+     * See v0.13 release notes for more information.
+     * Will be removed in a future version.
+     */
+    unsubscribe: {
+        /**
+         * @deprecated use the callback returned by subscribe instead.
+         * See v0.13 release notes for more information.
+         * Will be removed in a future version.
+         */
+        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): void;
+        /**
+         * @deprecated use the callback returned by subscribe instead.
+         * See v0.13 release notes for more information.
+         * Will be removed in a future version.
+         */
+        <T extends Presence>(type: "others", listener: OthersEventCallback<T>): void;
+        /**
+         * @deprecated use the callback returned by subscribe instead.
+         * See v0.13 release notes for more information.
+         * Will be removed in a future version.
          */
         (type: "event", listener: EventCallback): void;
         /**
-         * Unsubscribe to errors thrown in the room.
+         * @deprecated use the callback returned by subscribe instead.
+         * See v0.13 release notes for more information.
+         * Will be removed in a future version.
          */
         (type: "error", listener: ErrorCallback): void;
         /**
-         * Unsubscribe to connection state updates.
+         * @deprecated use the callback returned by subscribe instead.
+         * See v0.13 release notes for more information.
+         * Will be removed in a future version.
          */
         (type: "connection", listener: ConnectionCallback): void;
     };
@@ -237,7 +392,8 @@ export declare type Room = {
     getOthers: <T extends Presence>() => Others<T>;
     /**
      * Updates the presence of the current user. Only pass the properties you want to update. No need to send the full presence.
-     * @param {Partial<T>} overrides - A partial object that contains the properties you want to update.
+     * @param overrides A partial object that contains the properties you want to update.
+     * @param overrides Optional object to configure the behavior of updatePresence.
      *
      * @example
      * room.updatePresence({ x: 0 });
@@ -246,10 +402,15 @@ export declare type Room = {
      * const presence = room.getPresence();
      * // presence is equivalent to { x: 0, y: 0 }
      */
-    updatePresence: <T extends Presence>(overrides: Partial<T>) => void;
+    updatePresence: <T extends Presence>(overrides: Partial<T>, options?: {
+        /**
+         * Whether or not the presence should have an impact on the undo/redo history.
+         */
+        addToHistory: boolean;
+    }) => void;
     /**
-     * Broadcast an event to other users in the room. Event broadcasted to the room can be listened with {@link Room.subscribe}("event").
-     * @param {any} event - the event to broadcast. Should be serializable to JSON
+     * Broadcasts an event to other users in the room. Event broadcasted to the room can be listened with {@link Room.subscribe}("event").
+     * @param {any} event the event to broadcast. Should be serializable to JSON
      *
      * @example
      * // On client A
@@ -263,10 +424,29 @@ export declare type Room = {
      * });
      */
     broadcastEvent: (event: any) => void;
+    /**
+     * Get the room's storage asynchronously.
+     * The storage's root is a {@link LiveObject}.
+     *
+     * @example
+     * const { root } = await room.getStorage();
+     */
     getStorage: <TRoot>() => Promise<{
         root: LiveObject<TRoot>;
     }>;
-    undo: () => void;
-    redo: () => void;
+    /**
+     * Batches modifications made during the given function.
+     * All the modifications are sent to other clients in a single message.
+     * All the subscribers are called only after the batch is over.
+     * All the modifications are merged in a single history item (undo/redo).
+     *
+     * @example
+     * const { root } = await room.getStorage();
+     * room.batch(() => {
+     *   root.set("x", 0);
+     *   room.updatePresence({ cursor: { x: 100, y: 100 }});
+     * });
+     */
+    batch: (fn: () => void) => void;
 };
 export {};

package/lib/cjs/utils.d.ts

@@ -1 +1,8 @@
+import { AbstractCrdt, Doc } from "./AbstractCrdt";
+import { SerializedCrdtWithId } from "./live";
 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;

package/lib/cjs/utils.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remove = void 0;
+exports.selfOrRegister = exports.selfOrRegisterValue = exports.isCrdt = exports.deserialize = exports.isSameNodeOrChildOf = exports.remove = void 0;
+const live_1 = require("./live");
+const LiveList_1 = require("./LiveList");
+const LiveMap_1 = require("./LiveMap");
+const LiveObject_1 = require("./LiveObject");
+const LiveRegister_1 = require("./LiveRegister");
 function remove(array, item) {
     for (let i = 0; i < array.length; i++) {
         if (array[i] === item) {
@@ -10,3 +15,61 @@ function remove(array, item) {
     }
 }
 exports.remove = remove;
+function isSameNodeOrChildOf(node, parent) {
+    if (node === parent) {
+        return true;
+    }
+    if (node._parent) {
+        return isSameNodeOrChildOf(node._parent, parent);
+    }
+    return false;
+}
+exports.isSameNodeOrChildOf = isSameNodeOrChildOf;
+function deserialize(entry, parentToChildren, doc) {
+    switch (entry[1].type) {
+        case live_1.CrdtType.Object: {
+            return LiveObject_1.LiveObject._deserialize(entry, parentToChildren, doc);
+        }
+        case live_1.CrdtType.List: {
+            return LiveList_1.LiveList._deserialize(entry, parentToChildren, doc);
+        }
+        case live_1.CrdtType.Map: {
+            return LiveMap_1.LiveMap._deserialize(entry, parentToChildren, doc);
+        }
+        case live_1.CrdtType.Register: {
+            return LiveRegister_1.LiveRegister._deserialize(entry, parentToChildren, doc);
+        }
+        default: {
+            throw new Error("Unexpected CRDT type");
+        }
+    }
+}
+exports.deserialize = deserialize;
+function isCrdt(obj) {
+    return (obj instanceof LiveObject_1.LiveObject ||
+        obj instanceof LiveMap_1.LiveMap ||
+        obj instanceof LiveList_1.LiveList ||
+        obj instanceof LiveRegister_1.LiveRegister);
+}
+exports.isCrdt = isCrdt;
+function selfOrRegisterValue(obj) {
+    if (obj instanceof LiveRegister_1.LiveRegister) {
+        return obj.data;
+    }
+    return obj;
+}
+exports.selfOrRegisterValue = selfOrRegisterValue;
+function selfOrRegister(obj) {
+    if (obj instanceof LiveObject_1.LiveObject ||
+        obj instanceof LiveMap_1.LiveMap ||
+        obj instanceof LiveList_1.LiveList) {
+        return obj;
+    }
+    else if (obj instanceof LiveRegister_1.LiveRegister) {
+        throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
+    }
+    else {
+        return new LiveRegister_1.LiveRegister(obj);
+    }
+}
+exports.selfOrRegister = selfOrRegister;

package/lib/esm/AbstractCrdt.d.ts

@@ -0,0 +1,61 @@
+import { Op } from "./live";
+export declare type ApplyResult = {
+    reverse: Op[];
+    modified: AbstractCrdt;
+} | {
+    modified: false;
+};
+export interface Doc {
+    generateId: () => string;
+    generateOpId: () => string;
+    addItem: (id: string, item: AbstractCrdt) => void;
+    deleteItem: (id: string) => void;
+    dispatch: (ops: Op[], reverseOps: Op[], modified: AbstractCrdt[]) => void;
+}
+export declare abstract class AbstractCrdt {
+    #private;
+    /**
+     * INTERNAL
+     */
+    protected get _doc(): Doc | undefined;
+    /**
+     * INTERNAL
+     */
+    get _id(): string | undefined;
+    /**
+     * INTERNAL
+     */
+    get _parent(): AbstractCrdt | undefined;
+    /**
+     * INTERNAL
+     */
+    get _parentKey(): string | undefined;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent: AbstractCrdt, key: string): void;
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    abstract _detachChild(crdt: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    abstract _serialize(parentId: string, parentKey: string): Op[];
+}

package/lib/esm/AbstractCrdt.js

@@ -0,0 +1,94 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _AbstractCrdt_parent, _AbstractCrdt_doc, _AbstractCrdt_id, _AbstractCrdt_parentKey;
+import { OpType } from "./live";
+export class AbstractCrdt {
+    constructor() {
+        _AbstractCrdt_parent.set(this, void 0);
+        _AbstractCrdt_doc.set(this, void 0);
+        _AbstractCrdt_id.set(this, void 0);
+        _AbstractCrdt_parentKey.set(this, void 0);
+    }
+    /**
+     * INTERNAL
+     */
+    get _doc() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_doc, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _id() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_id, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _parent() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_parent, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _parentKey() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_parentKey, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        switch (op.type) {
+            case OpType.DeleteCrdt: {
+                if (this._parent != null && this._parentKey != null) {
+                    const parent = this._parent;
+                    const reverse = this._serialize(this._parent._id, this._parentKey);
+                    this._parent._detachChild(this);
+                    return { modified: parent, reverse };
+                }
+                return { modified: false };
+            }
+        }
+        return { modified: false };
+    }
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent, key) {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_parent, "f") != null && __classPrivateFieldGet(this, _AbstractCrdt_parent, "f") !== parent) {
+            throw new Error("Cannot attach parent if it already exist");
+        }
+        __classPrivateFieldSet(this, _AbstractCrdt_parentKey, key, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_parent, parent, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_id, "f") || __classPrivateFieldGet(this, _AbstractCrdt_doc, "f")) {
+            throw new Error("Cannot attach if CRDT is already attached");
+        }
+        doc.addItem(id, this);
+        __classPrivateFieldSet(this, _AbstractCrdt_id, id, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_doc, doc, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_doc, "f") && __classPrivateFieldGet(this, _AbstractCrdt_id, "f")) {
+            __classPrivateFieldGet(this, _AbstractCrdt_doc, "f").deleteItem(__classPrivateFieldGet(this, _AbstractCrdt_id, "f"));
+        }
+        __classPrivateFieldSet(this, _AbstractCrdt_parent, undefined, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_doc, undefined, "f");
+    }
+}
+_AbstractCrdt_parent = new WeakMap(), _AbstractCrdt_doc = new WeakMap(), _AbstractCrdt_id = new WeakMap(), _AbstractCrdt_parentKey = new WeakMap();