@textbus/collaborate 4.0.0-alpha.24 → 4.0.0-alpha.27

package/bundles/index.js

@@ -43,7 +43,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 const collaborateErrorFn = core.makeError('Collaborate');
-class ContentMap {
+class SlotMap {
     constructor() {
         this.slotAndYTextMap = new WeakMap();
         this.yTextAndSLotMap = new WeakMap();
@@ -107,13 +107,9 @@ exports.Collaborate = class Collaborate {
         this.manager = null;
         this.subscriptions = [];
         this.updateFromRemote = false;
-        this.contentSyncCaches = new WeakMap();
-        this.slotStateSyncCaches = new WeakMap();
-        this.slotsSyncCaches = new WeakMap();
-        this.componentStateSyncCaches = new WeakMap();
         this.localChangesAppliedEvent = new stream.Subject();
         this.selectionChangeEvent = new stream.Subject();
-        this.contentMap = new ContentMap();
+        this.slotMap = new SlotMap();
         this.updateRemoteActions = [];
         this.noRecord = {};
         this.historyItems = [];
@@ -148,7 +144,7 @@ exports.Collaborate = class Collaborate {
         this.subscriptions.push(this.scheduler.onLocalChangeBefore.subscribe(() => {
             beforePosition = this.getRelativeCursorLocation();
         }));
-        manager.on('stack-item-added', event => {
+        manager.on('stack-item-added', (event) => {
             if (event.type === 'undo') {
                 if (event.origin === manager) {
                     this.index++;
@@ -260,50 +256,153 @@ exports.Collaborate = class Collaborate {
         (_a = this.manager) === null || _a === void 0 ? void 0 : _a.destroy();
     }
     syncRootComponent(root, rootComponent) {
-        let slots = root.get('slots');
-        if (!slots) {
-            slots = new yjs.Array();
-            rootComponent.slots.toArray().forEach(i => {
-                const sharedSlot = this.createSharedSlotBySlot(i);
-                slots.push([sharedSlot]);
-            });
+        let state = root.get('state');
+        if (!state) {
+            state = new yjs.Map();
+            this.syncLocalMapToSharedMap(rootComponent.state, state, rootComponent);
             this.yDoc.transact(() => {
-                root.set('state', rootComponent.state);
-                root.set('slots', slots);
+                root.set('state', state);
             });
         }
-        else if (slots.length === 0) {
-            rootComponent.updateState(() => {
-                return root.get('state');
-            });
-            this.yDoc.transact(() => {
-                rootComponent.slots.toArray().forEach(i => {
-                    const sharedSlot = this.createSharedSlotBySlot(i);
-                    slots.push([sharedSlot]);
+        else {
+            rootComponent.state.clean();
+            this.syncSharedMapToLocalMap(state, rootComponent.state, rootComponent);
+        }
+    }
+    syncSharedMapToLocalMap(sharedMap, localMap, parent) {
+        sharedMap.forEach((value, key) => {
+            localMap.set(key, this.createLocalModelBySharedByModel(value, parent));
+        });
+        this.syncObject(sharedMap, localMap, parent);
+    }
+    createLocalMapBySharedMap(sharedMap, parent) {
+        const localMap = new core.MapModel(parent);
+        this.syncSharedMapToLocalMap(sharedMap, localMap, parent);
+        return localMap;
+    }
+    createLocalArrayBySharedArray(sharedArray, parent) {
+        const localArray = new core.ArrayModel(parent);
+        sharedArray.forEach(item => {
+            localArray.insert(this.createLocalModelBySharedByModel(item, parent));
+        });
+        this.syncArray(sharedArray, localArray, parent);
+        return localArray;
+    }
+    syncLocalMapToSharedMap(localMap, sharedMap, parent) {
+        localMap.forEach((value, key) => {
+            sharedMap.set(key, this.createSharedModelByLocalModel(value, parent));
+        });
+        this.syncObject(sharedMap, localMap, parent);
+    }
+    createSharedMapByLocalMap(localMap, parent) {
+        const sharedMap = new yjs.Map();
+        this.syncLocalMapToSharedMap(localMap, sharedMap, parent);
+        return sharedMap;
+    }
+    createSharedArrayByLocalArray(localArray, parent) {
+        const sharedArray = new yjs.Array();
+        localArray.forEach(value => {
+            sharedArray.push([this.createSharedModelByLocalModel(value, parent)]);
+        });
+        this.syncArray(sharedArray, localArray, parent);
+        return sharedArray;
+    }
+    createSharedSlotByLocalSlot(localSlot) {
+        const sharedSlot = new yjs.Text();
+        sharedSlot.setAttribute('__schema__', [...localSlot.schema]);
+        let offset = 0;
+        localSlot.toDelta().forEach(i => {
+            let formats = {};
+            if (i.formats) {
+                i.formats.forEach(item => {
+                    formats[item[0].name] = item[1];
                 });
-            });
+            }
+            else {
+                formats = null;
+            }
+            if (typeof i.insert === 'string') {
+                sharedSlot.insert(offset, i.insert, formats);
+            }
+            else {
+                const sharedComponent = this.createSharedComponentByLocalComponent(i.insert);
+                sharedSlot.insertEmbed(offset, sharedComponent, formats);
+            }
+            offset += i.insert.length;
+        });
+        localSlot.getAttributes().forEach(item => {
+            sharedSlot.setAttribute(item[0].name, item[1]);
+        });
+        this.syncSlot(sharedSlot, localSlot);
+        return sharedSlot;
+    }
+    createLocalSlotBySharedSlot(sharedSlot) {
+        const delta = sharedSlot.toDelta();
+        const localSlot = new core.Slot(sharedSlot.getAttribute('__schema__') || []); // TODO 这里有潜在的问题
+        const attrs = sharedSlot.getAttributes();
+        Object.keys(attrs).forEach(key => {
+            const attribute = this.registry.getAttribute(key);
+            if (attribute) {
+                localSlot.setAttribute(attribute, attrs[key]);
+            }
+        });
+        for (const action of delta) {
+            if (action.insert) {
+                if (typeof action.insert === 'string') {
+                    const formats = remoteFormatsToLocal(this.registry, action.attributes);
+                    localSlot.insert(action.insert, formats);
+                }
+                else {
+                    const sharedComponent = action.insert;
+                    const component = this.createLocalComponentBySharedComponent(sharedComponent);
+                    localSlot.insert(component, remoteFormatsToLocal(this.registry, action.attributes));
+                }
+            }
+            else {
+                throw collaborateErrorFn('unexpected delta action.');
+            }
         }
-        else {
-            rootComponent.updateState(() => {
-                return root.get('state');
-            });
-            rootComponent.slots.clean();
-            slots.forEach(sharedSlot => {
-                const slot = this.createSlotBySharedSlot(sharedSlot);
-                this.syncSlotContent(sharedSlot.get('content'), slot);
-                this.syncSlotState(sharedSlot, slot);
-                rootComponent.slots.insert(slot);
-            });
+        this.syncSlot(sharedSlot, localSlot);
+        return localSlot;
+    }
+    // private createSharedModelByLocalModel(sharedModel: YMap<any>, parent: Component<any>): MapModel<any>
+    // private createSharedModelByLocalModel(sharedModel: YArray<any>, parent: Component<any>): ArrayModel<any>
+    // private createSharedModelByLocalModel(sharedModel: YText, parent: Component<any>): Slot
+    // private createSharedModelByLocalModel(sharedModel: any, parent: Component<any>): any
+    createSharedModelByLocalModel(sharedModel, parent) {
+        if (sharedModel instanceof core.MapModel) {
+            return this.createSharedMapByLocalMap(sharedModel, parent);
+        }
+        if (sharedModel instanceof core.ArrayModel) {
+            return this.createSharedArrayByLocalArray(sharedModel, parent);
+        }
+        if (sharedModel instanceof core.Slot) {
+            return this.createSharedSlotByLocalSlot(sharedModel);
         }
-        this.syncComponentState(root, rootComponent);
-        this.syncComponentSlots(slots, rootComponent);
+        return sharedModel;
+    }
+    // private createLocalModelBySharedByModel(localModel: MapModel<any>, parent: Component<any>): MapModel<any>
+    // private createLocalModelBySharedByModel(localModel: ArrayModel<any>, parent: Component<any>): YArray<any>
+    // private createLocalModelBySharedByModel(localModel: Slot, parent: Component<any>): YText
+    // private createLocalModelBySharedByModel(localModel: any, parent: Component<any>): any
+    createLocalModelBySharedByModel(localModel, parent) {
+        if (localModel instanceof yjs.Map) {
+            return this.createLocalMapBySharedMap(localModel, parent);
+        }
+        if (localModel instanceof yjs.Array) {
+            return this.createLocalArrayBySharedArray(localModel, parent);
+        }
+        if (localModel instanceof yjs.Text) {
+            return this.createLocalSlotBySharedSlot(localModel);
+        }
+        return localModel;
     }
     getAbstractSelection(position) {
         const anchorPosition = yjs.createAbsolutePositionFromRelativePosition(position.anchor, this.yDoc);
         const focusPosition = yjs.createAbsolutePositionFromRelativePosition(position.focus, this.yDoc);
         if (anchorPosition && focusPosition) {
-            const focusSlot = this.contentMap.get(focusPosition.type);
-            const anchorSlot = this.contentMap.get(anchorPosition.type);
+            const focusSlot = this.slotMap.get(focusPosition.type);
+            const anchorSlot = this.slotMap.get(anchorPosition.type);
             if (focusSlot && anchorSlot) {
                 return {
                     anchorSlot,
@@ -318,11 +417,11 @@ exports.Collaborate = class Collaborate {
     getRelativeCursorLocation() {
         const { anchorSlot, anchorOffset, focusSlot, focusOffset } = this.selection;
         if (anchorSlot) {
-            const anchorYText = this.contentMap.get(anchorSlot);
+            const anchorYText = this.slotMap.get(anchorSlot);
             if (anchorYText) {
                 const anchorPosition = yjs.createRelativePositionFromTypeIndex(anchorYText, anchorOffset);
                 if (focusSlot) {
-                    const focusYText = this.contentMap.get(focusSlot);
+                    const focusYText = this.slotMap.get(focusSlot);
                     if (focusYText) {
                         const focusPosition = yjs.createRelativePositionFromTypeIndex(focusYText, focusOffset);
                         return {
@@ -335,11 +434,10 @@ exports.Collaborate = class Collaborate {
         }
         return null;
     }
-    syncSlotContent(content, slot) {
-        this.contentMap.set(slot, content);
+    syncSlot(sharedSlot, localSlot) {
         const syncRemote = (ev, tr) => {
             this.runRemoteUpdate(tr, () => {
-                slot.retain(0);
+                localSlot.retain(0);
                 ev.keysChanged.forEach(key => {
                     const change = ev.keys.get(key);
                     if (!change) {
@@ -349,13 +447,13 @@ exports.Collaborate = class Collaborate {
                     if (updateType === 'update' || updateType === 'add') {
                         const attribute = this.registry.getAttribute(key);
                         if (attribute) {
-                            slot.setAttribute(attribute, content.getAttribute(key));
+                            localSlot.setAttribute(attribute, sharedSlot.getAttribute(key));
                         }
                     }
                     else if (updateType === 'delete') {
                         const attribute = this.registry.getAttribute(key);
                         if (attribute) {
-                            slot.removeAttribute(attribute);
+                            localSlot.removeAttribute(attribute);
                         }
                     }
                 });
@@ -364,54 +462,52 @@ exports.Collaborate = class Collaborate {
                         if (action.attributes) {
                             const formats = remoteFormatsToLocal(this.registry, action.attributes);
                             if (formats.length) {
-                                slot.retain(action.retain, formats);
+                                localSlot.retain(action.retain, formats);
                             }
-                            slot.retain(slot.index + action.retain);
+                            localSlot.retain(localSlot.index + action.retain);
                         }
                         else {
-                            slot.retain(action.retain);
+                            localSlot.retain(action.retain);
                         }
                     }
                     else if (action.insert) {
-                        const index = slot.index;
+                        const index = localSlot.index;
                         let length = 1;
                         if (typeof action.insert === 'string') {
                             length = action.insert.length;
-                            slot.insert(action.insert, remoteFormatsToLocal(this.registry, action.attributes));
+                            localSlot.insert(action.insert, remoteFormatsToLocal(this.registry, action.attributes));
                         }
                         else {
                             const sharedComponent = action.insert;
-                            const component = this.createComponentBySharedComponent(sharedComponent);
-                            this.syncComponentSlots(sharedComponent.get('slots'), component);
-                            this.syncComponentState(sharedComponent, component);
-                            slot.insert(component);
+                            const component = this.createLocalComponentBySharedComponent(sharedComponent);
+                            localSlot.insert(component);
                         }
                         if (this.selection.isSelected && tr.origin !== this.manager) {
-                            if (slot === this.selection.anchorSlot && this.selection.anchorOffset > index) {
-                                this.selection.setAnchor(slot, this.selection.anchorOffset + length);
+                            if (localSlot === this.selection.anchorSlot && this.selection.anchorOffset > index) {
+                                this.selection.setAnchor(localSlot, this.selection.anchorOffset + length);
                             }
-                            if (slot === this.selection.focusSlot && this.selection.focusOffset > index) {
-                                this.selection.setFocus(slot, this.selection.focusOffset + length);
+                            if (localSlot === this.selection.focusSlot && this.selection.focusOffset > index) {
+                                this.selection.setFocus(localSlot, this.selection.focusOffset + length);
                             }
                         }
                     }
                     else if (action.delete) {
-                        const index = slot.index;
-                        slot.delete(action.delete);
+                        const index = localSlot.index;
+                        localSlot.delete(action.delete);
                         if (this.selection.isSelected && tr.origin !== this.manager) {
-                            if (slot === this.selection.anchorSlot && this.selection.anchorOffset >= index) {
-                                this.selection.setAnchor(slot, this.selection.startOffset - action.delete);
+                            if (localSlot === this.selection.anchorSlot && this.selection.anchorOffset >= index) {
+                                this.selection.setAnchor(localSlot, this.selection.startOffset - action.delete);
                             }
-                            if (slot === this.selection.focusSlot && this.selection.focusOffset >= index) {
-                                this.selection.setFocus(slot, this.selection.focusOffset - action.delete);
+                            if (localSlot === this.selection.focusSlot && this.selection.focusOffset >= index) {
+                                this.selection.setFocus(localSlot, this.selection.focusOffset - action.delete);
                             }
                         }
                     }
                 });
             });
         };
-        content.observe(syncRemote);
-        const sub = slot.onContentChange.subscribe(actions => {
+        sharedSlot.observe(syncRemote);
+        const sub = localSlot.onContentChange.subscribe(actions => {
             this.runLocalUpdate(() => {
                 var _a;
                 let offset = 0;
@@ -430,170 +526,169 @@ exports.Collaborate = class Collaborate {
                                 }
                             });
                             if (length) {
-                                content.format(offset, action.offset, formats);
+                                sharedSlot.format(offset, action.offset, formats);
                             }
                         }
                         else {
                             offset = action.offset;
                         }
                     }
-                    else if (action.type === 'insert') {
-                        const delta = content.toDelta();
+                    else if (action.type === 'contentInsert') {
+                        const delta = sharedSlot.toDelta();
                         const isEmpty = delta.length === 1 && delta[0].insert === core.Slot.emptyPlaceholder;
                         if (typeof action.content === 'string') {
                             length = action.content.length;
-                            content.insert(offset, action.content, action.formats || {});
+                            sharedSlot.insert(offset, action.content, action.formats || {});
                         }
                         else {
                             length = 1;
-                            const sharedComponent = this.createSharedComponentByComponent(action.ref);
-                            content.insertEmbed(offset, sharedComponent, action.formats || {});
+                            const sharedComponent = this.createSharedComponentByLocalComponent(action.ref);
+                            sharedSlot.insertEmbed(offset, sharedComponent, action.formats || {});
                         }
                         if (isEmpty && offset === 0) {
-                            content.delete(content.length - 1, 1);
+                            sharedSlot.delete(sharedSlot.length - 1, 1);
                         }
                         offset += length;
                     }
                     else if (action.type === 'delete') {
-                        const delta = content.toDelta();
-                        if (content.length) {
-                            content.delete(offset, action.count);
+                        const delta = sharedSlot.toDelta();
+                        if (sharedSlot.length) {
+                            sharedSlot.delete(offset, action.count);
                         }
-                        if (content.length === 0) {
-                            content.insert(0, '\n', (_a = delta[0]) === null || _a === void 0 ? void 0 : _a.attributes);
+                        if (sharedSlot.length === 0) {
+                            sharedSlot.insert(0, '\n', (_a = delta[0]) === null || _a === void 0 ? void 0 : _a.attributes);
                         }
                     }
                     else if (action.type === 'attrSet') {
-                        content.setAttribute(action.name, action.value);
+                        sharedSlot.setAttribute(action.name, action.value);
                     }
-                    else if (action.type === 'attrRemove') {
-                        content.removeAttribute(action.name);
+                    else if (action.type === 'attrDelete') {
+                        sharedSlot.removeAttribute(action.name);
                     }
                 }
             });
         });
-        sub.add(slot.onChildComponentRemove.subscribe(components => {
-            components.forEach(c => {
-                this.cleanSubscriptionsByComponent(c);
-            });
-        }));
-        this.contentSyncCaches.set(slot, () => {
-            content.unobserve(syncRemote);
+        this.slotMap.set(localSlot, sharedSlot);
+        localSlot.destroyCallbacks.push(() => {
+            this.slotMap.delete(localSlot);
+            sharedSlot.unobserve(syncRemote);
             sub.unsubscribe();
         });
     }
-    syncSlotState(remoteSlot, slot) {
-        const syncRemote = (ev, tr) => {
-            this.runRemoteUpdate(tr, () => {
-                ev.keysChanged.forEach(key => {
-                    if (key === 'state') {
-                        const state = ev.target.get('state');
-                        slot.updateState(draft => {
-                            if (typeof draft === 'object' && draft !== null) {
-                                Object.assign(draft, state);
-                            }
-                            else {
-                                return state;
+    createSharedComponentByLocalComponent(component) {
+        const sharedComponent = new yjs.Map();
+        const sharedState = this.createSharedMapByLocalMap(component.state, component);
+        sharedComponent.set('name', component.name);
+        sharedComponent.set('state', sharedState);
+        return sharedComponent;
+    }
+    createLocalComponentBySharedComponent(yMap) {
+        const componentName = yMap.get('name');
+        const sharedState = yMap.get('state');
+        const instance = this.registry.createComponentByData(componentName, (component) => {
+            return this.createLocalMapBySharedMap(sharedState, component);
+        });
+        if (instance) {
+            return instance;
+        }
+        throw collaborateErrorFn(`cannot find component factory \`${componentName}\`.`);
+    }
+    /**
+     * 双向同步数组
+     * @param sharedArray
+     * @param localArray
+     * @param parent
+     * @private
+     */
+    syncArray(sharedArray, localArray, parent) {
+        const sub = localArray.changeMarker.onChange.subscribe((op) => {
+            this.runLocalUpdate(() => {
+                let index = 0;
+                for (const action of op.apply) {
+                    switch (action.type) {
+                        case 'retain':
+                            index = action.offset;
+                            break;
+                        case 'insert':
+                            {
+                                const data = this.createSharedModelByLocalModel(action.ref, parent);
+                                sharedArray.insert(index, [data]);
                             }
-                        });
+                            break;
+                        case 'delete':
+                            sharedArray.delete(index, 1);
+                            break;
                     }
-                });
+                }
             });
-        };
-        remoteSlot.observe(syncRemote);
-        const sub = slot.onStateChange.subscribe(change => {
-            this.runLocalUpdate(() => {
-                remoteSlot.set('state', change.newState);
-            }, change.record);
         });
-        this.slotStateSyncCaches.set(slot, () => {
-            remoteSlot.unobserve(syncRemote);
-            sub.unsubscribe();
-        });
-    }
-    syncComponentSlots(remoteSlots, component) {
-        const slots = component.slots;
         const syncRemote = (ev, tr) => {
             this.runRemoteUpdate(tr, () => {
                 let index = 0;
-                slots.retain(index);
-                ev.delta.forEach(action => {
+                localArray.retain(index);
+                ev.delta.forEach((action) => {
                     if (Reflect.has(action, 'retain')) {
                         index += action.retain;
-                        slots.retain(index);
+                        localArray.retain(index);
                     }
                     else if (action.insert) {
-                        action.insert.forEach(item => {
-                            const slot = this.createSlotBySharedSlot(item);
-                            slots.insert(slot);
-                            this.syncSlotContent(item.get('content'), slot);
-                            this.syncSlotState(item, slot);
+                        action.insert.forEach((item) => {
+                            const value = this.createLocalModelBySharedByModel(item, parent);
+                            localArray.insert(value);
                             index++;
                         });
                     }
                     else if (action.delete) {
-                        slots.retain(index);
-                        slots.delete(action.delete);
+                        localArray.retain(index);
+                        localArray.delete(action.delete);
                     }
                 });
             });
         };
-        remoteSlots.observe(syncRemote);
-        const sub = slots.onChange.subscribe(operations => {
-            this.runLocalUpdate(() => {
-                const applyActions = operations.apply;
-                let index;
-                applyActions.forEach(action => {
-                    if (action.type === 'retain') {
-                        index = action.offset;
-                    }
-                    else if (action.type === 'insertSlot') {
-                        const sharedSlot = this.createSharedSlotBySlot(action.ref);
-                        remoteSlots.insert(index, [sharedSlot]);
-                        index++;
-                    }
-                    else if (action.type === 'delete') {
-                        remoteSlots.delete(index, action.count);
-                    }
-                });
-            });
-        });
-        sub.add(slots.onChildSlotRemove.subscribe(slots => {
-            slots.forEach(slot => {
-                this.cleanSubscriptionsBySlot(slot);
-            });
-        }));
-        this.slotsSyncCaches.set(component, () => {
-            remoteSlots.unobserve(syncRemote);
+        sharedArray.observe(syncRemote);
+        localArray.destroyCallbacks.push(() => {
             sub.unsubscribe();
+            sharedArray.unobserve(syncRemote);
         });
     }
-    syncComponentState(remoteComponent, component) {
+    /**
+     * 双向同步对象
+     * @param sharedObject
+     * @param localObject
+     * @param parent
+     * @private
+     */
+    syncObject(sharedObject, localObject, parent) {
         const syncRemote = (ev, tr) => {
             this.runRemoteUpdate(tr, () => {
-                ev.keysChanged.forEach(key => {
-                    if (key === 'state') {
-                        const state = ev.target.get('state');
-                        component.updateState(draft => {
-                            if (typeof draft === 'object' && draft !== null) {
-                                Object.assign(draft, state);
-                            }
-                            else {
-                                return state;
-                            }
-                        });
+                ev.changes.keys.forEach((item, key) => {
+                    if (item.action === 'add' || item.action === 'update') {
+                        const value = sharedObject.get(key);
+                        localObject.set(key, this.createLocalModelBySharedByModel(value, parent));
+                    }
+                    else {
+                        localObject.remove(key);
                     }
                 });
             });
         };
-        remoteComponent.observe(syncRemote);
-        const sub = component.onStateChange.subscribe(change => {
+        sharedObject.observe(syncRemote);
+        const sub = localObject.changeMarker.onChange.subscribe((op) => {
             this.runLocalUpdate(() => {
-                remoteComponent.set('state', change.newState);
-            }, change.record);
+                for (const action of op.apply) {
+                    switch (action.type) {
+                        case 'propSet':
+                            sharedObject.set(action.key, this.createSharedModelByLocalModel(action.value, parent));
+                            break;
+                        case 'propDelete':
+                            sharedObject.delete(action.key);
+                            break;
+                    }
+                }
+            });
         });
-        this.componentStateSyncCaches.set(component, () => {
-            remoteComponent.unobserve(syncRemote);
+        localObject.destroyCallbacks.push(function () {
+            sharedObject.unobserve(syncRemote);
             sub.unsubscribe();
         });
     }
@@ -619,140 +714,6 @@ exports.Collaborate = class Collaborate {
         }
         this.updateFromRemote = false;
     }
-    createSharedComponentByComponent(component) {
-        const sharedComponent = new yjs.Map();
-        sharedComponent.set('state', component.state);
-        sharedComponent.set('name', component.name);
-        const sharedSlots = new yjs.Array();
-        sharedComponent.set('slots', sharedSlots);
-        component.slots.toArray().forEach(slot => {
-            const sharedSlot = this.createSharedSlotBySlot(slot);
-            sharedSlots.push([sharedSlot]);
-        });
-        this.syncComponentSlots(sharedSlots, component);
-        this.syncComponentState(sharedComponent, component);
-        return sharedComponent;
-    }
-    createSharedSlotBySlot(slot) {
-        const sharedSlot = new yjs.Map();
-        sharedSlot.set('schema', slot.schema);
-        sharedSlot.set('state', slot.state);
-        const sharedContent = new yjs.Text();
-        sharedSlot.set('content', sharedContent);
-        let offset = 0;
-        slot.toDelta().forEach(i => {
-            let formats = {};
-            if (i.formats) {
-                i.formats.forEach(item => {
-                    formats[item[0].name] = item[1];
-                });
-            }
-            else {
-                formats = null;
-            }
-            if (typeof i.insert === 'string') {
-                sharedContent.insert(offset, i.insert, formats);
-            }
-            else {
-                const sharedComponent = this.createSharedComponentByComponent(i.insert);
-                sharedContent.insertEmbed(offset, sharedComponent, formats);
-            }
-            offset += i.insert.length;
-        });
-        slot.getAttributes().forEach(item => {
-            sharedContent.setAttribute(item[0].name, item[1]);
-        });
-        this.syncSlotContent(sharedContent, slot);
-        this.syncSlotState(sharedSlot, slot);
-        return sharedSlot;
-    }
-    createComponentBySharedComponent(yMap) {
-        const sharedSlots = yMap.get('slots');
-        const slots = [];
-        sharedSlots.forEach(sharedSlot => {
-            const slot = this.createSlotBySharedSlot(sharedSlot);
-            slots.push(slot);
-        });
-        const name = yMap.get('name');
-        const state = yMap.get('state');
-        const instance = this.registry.createComponentByData(name, {
-            state,
-            slots
-        });
-        if (instance) {
-            instance.slots.toArray().forEach((slot, index) => {
-                let sharedSlot = sharedSlots.get(index);
-                if (!sharedSlot) {
-                    sharedSlot = this.createSharedSlotBySlot(slot);
-                    sharedSlots.push([sharedSlot]);
-                }
-                this.syncSlotState(sharedSlot, slot);
-                this.syncSlotContent(sharedSlot.get('content'), slot);
-            });
-            return instance;
-        }
-        throw collaborateErrorFn(`cannot find component factory \`${name}\`.`);
-    }
-    createSlotBySharedSlot(sharedSlot) {
-        const content = sharedSlot.get('content');
-        const delta = content.toDelta();
-        const slot = this.registry.createSlot({
-            schema: sharedSlot.get('schema'),
-            state: sharedSlot.get('state'),
-            attributes: {},
-            formats: {},
-            content: []
-        });
-        const attrs = content.getAttributes();
-        Object.keys(attrs).forEach(key => {
-            const attribute = this.registry.getAttribute(key);
-            if (attribute) {
-                slot.setAttribute(attribute, attrs[key]);
-            }
-        });
-        for (const action of delta) {
-            if (action.insert) {
-                if (typeof action.insert === 'string') {
-                    const formats = remoteFormatsToLocal(this.registry, action.attributes);
-                    slot.insert(action.insert, formats);
-                }
-                else {
-                    const sharedComponent = action.insert;
-                    const component = this.createComponentBySharedComponent(sharedComponent);
-                    slot.insert(component, remoteFormatsToLocal(this.registry, action.attributes));
-                    this.syncComponentSlots(sharedComponent.get('slots'), component);
-                    this.syncComponentState(sharedComponent, component);
-                }
-            }
-            else {
-                throw collaborateErrorFn('unexpected delta action.');
-            }
-        }
-        return slot;
-    }
-    cleanSubscriptionsBySlot(slot) {
-        this.contentMap.delete(slot);
-        [this.contentSyncCaches.get(slot), this.slotStateSyncCaches.get(slot)].forEach(fn => {
-            if (fn) {
-                fn();
-            }
-        });
-        slot.sliceContent().forEach(i => {
-            if (typeof i !== 'string') {
-                this.cleanSubscriptionsByComponent(i);
-            }
-        });
-    }
-    cleanSubscriptionsByComponent(component) {
-        [this.slotsSyncCaches.get(component), this.componentStateSyncCaches.get(component)].forEach(fn => {
-            if (fn) {
-                fn();
-            }
-        });
-        component.slots.toArray().forEach(slot => {
-            this.cleanSubscriptionsBySlot(slot);
-        });
-    }
 };
 exports.Collaborate = __decorate([
     core$1.Injectable(),