@textbus/collaborate 3.0.0-alpha.9 → 3.0.0

package/bundles/index.js

@@ -0,0 +1,778 @@
+'use strict';
+
+var core = require('@textbus/core');
+var di = require('@tanbo/di');
+var stream = require('@tanbo/stream');
+var yjs = require('yjs');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+const collaborateErrorFn = core.makeError('Collaborate');
+class ContentMap {
+    constructor() {
+        this.slotAndYTextMap = new WeakMap();
+        this.yTextAndSLotMap = new WeakMap();
+    }
+    set(key, value) {
+        if (key instanceof core.Slot) {
+            this.slotAndYTextMap.set(key, value);
+            this.yTextAndSLotMap.set(value, key);
+        }
+        else {
+            this.slotAndYTextMap.set(value, key);
+            this.yTextAndSLotMap.set(key, value);
+        }
+    }
+    get(key) {
+        if (key instanceof core.Slot) {
+            return this.slotAndYTextMap.get(key) || null;
+        }
+        return this.yTextAndSLotMap.get(key) || null;
+    }
+    delete(key) {
+        if (key instanceof core.Slot) {
+            const v = this.slotAndYTextMap.get(key);
+            this.slotAndYTextMap.delete(key);
+            if (v) {
+                this.yTextAndSLotMap.delete(v);
+            }
+        }
+        else {
+            const v = this.yTextAndSLotMap.get(key);
+            this.yTextAndSLotMap.delete(key);
+            if (v) {
+                this.slotAndYTextMap.delete(v);
+            }
+        }
+    }
+}
+class CustomUndoManagerConfig {
+}
+exports.Collaborate = class Collaborate {
+    get canBack() {
+        var _a;
+        return ((_a = this.manager) === null || _a === void 0 ? void 0 : _a.canUndo()) || false;
+    }
+    get canForward() {
+        var _a;
+        return ((_a = this.manager) === null || _a === void 0 ? void 0 : _a.canRedo()) || false;
+    }
+    constructor(stackSize, rootComponentRef, controller, scheduler, registry, selection, starter, undoManagerConfig) {
+        this.stackSize = stackSize;
+        this.rootComponentRef = rootComponentRef;
+        this.controller = controller;
+        this.scheduler = scheduler;
+        this.registry = registry;
+        this.selection = selection;
+        this.starter = starter;
+        this.undoManagerConfig = undoManagerConfig;
+        this.yDoc = new yjs.Doc();
+        this.backEvent = new stream.Subject();
+        this.forwardEvent = new stream.Subject();
+        this.changeEvent = new stream.Subject();
+        this.pushEvent = new stream.Subject();
+        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.updateRemoteActions = [];
+        this.noRecord = {};
+        this.historyItems = [];
+        this.index = 0;
+        this.onBack = this.backEvent.asObservable();
+        this.onForward = this.forwardEvent.asObservable();
+        this.onChange = this.changeEvent.asObservable();
+        this.onPush = this.pushEvent.asObservable();
+        this.onLocalChangesApplied = this.localChangesAppliedEvent.asObservable();
+    }
+    listen() {
+        const root = this.yDoc.getMap('RootComponent');
+        const rootComponent = this.rootComponentRef.component;
+        const undoManagerConfig = this.undoManagerConfig || {};
+        const manager = new yjs.UndoManager(root, {
+            trackedOrigins: new Set([this.yDoc]),
+            captureTransaction(arg) {
+                if (undoManagerConfig.captureTransaction) {
+                    return undoManagerConfig.captureTransaction(arg);
+                }
+                return true;
+            },
+            deleteFilter(item) {
+                if (undoManagerConfig.deleteFilter) {
+                    return undoManagerConfig.deleteFilter(item);
+                }
+                return true;
+            }
+        });
+        this.manager = manager;
+        manager.on('stack-item-added', event => {
+            if (event.type === 'undo') {
+                if (event.origin === manager) {
+                    this.index++;
+                }
+                else {
+                    this.historyItems.length = this.index;
+                    this.historyItems.push(this.getRelativeCursorLocation());
+                    this.index++;
+                }
+            }
+            else {
+                this.index--;
+            }
+            if (manager.undoStack.length > this.stackSize) {
+                this.historyItems.shift();
+                manager.undoStack.shift();
+            }
+            if (event.origin === this.yDoc) {
+                this.pushEvent.next();
+            }
+            this.changeEvent.next();
+        });
+        manager.on('stack-item-popped', () => {
+            const position = this.historyItems[this.index - 1];
+            if (position) {
+                const selection = this.getAbstractSelection(position);
+                if (selection) {
+                    this.selection.setBaseAndExtent(selection.anchorSlot, selection.anchorOffset, selection.focusSlot, selection.focusOffset);
+                    return;
+                }
+            }
+            this.selection.unSelect();
+        });
+        this.subscriptions.push(this.selection.onChange.subscribe(() => {
+            const paths = this.selection.getPaths();
+            this.selectionChangeEvent.next(paths);
+        }), this.scheduler.onDocChanged.pipe(stream.map(item => {
+            return item.filter(i => {
+                return i.from !== core.ChangeOrigin.Remote;
+            });
+        }), stream.filter(item => {
+            return item.length;
+        })).subscribe(() => {
+            const updates = [];
+            let update = null;
+            for (const item of this.updateRemoteActions) {
+                if (!update) {
+                    update = {
+                        record: item.record,
+                        actions: []
+                    };
+                    updates.push(update);
+                }
+                if (update.record === item.record) {
+                    update.actions.push(item.action);
+                }
+                else {
+                    update = {
+                        record: item.record,
+                        actions: [item.action]
+                    };
+                    updates.push(update);
+                }
+            }
+            this.updateRemoteActions = [];
+            for (const item of updates) {
+                this.yDoc.transact(() => {
+                    item.actions.forEach(fn => {
+                        fn();
+                    });
+                }, item.record ? this.yDoc : this.noRecord);
+            }
+            this.localChangesAppliedEvent.next();
+        }));
+        this.syncRootComponent(root, rootComponent);
+    }
+    back() {
+        var _a;
+        if (this.canBack) {
+            (_a = this.manager) === null || _a === void 0 ? void 0 : _a.undo();
+            this.backEvent.next();
+        }
+    }
+    forward() {
+        var _a;
+        if (this.canForward) {
+            (_a = this.manager) === null || _a === void 0 ? void 0 : _a.redo();
+            this.forwardEvent.next();
+        }
+    }
+    clear() {
+        var _a;
+        this.index = 0;
+        this.historyItems = [];
+        (_a = this.manager) === null || _a === void 0 ? void 0 : _a.clear();
+        this.changeEvent.next();
+    }
+    destroy() {
+        var _a;
+        this.index = 0;
+        this.historyItems = [];
+        this.subscriptions.forEach(i => i.unsubscribe());
+        (_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]);
+            });
+            this.yDoc.transact(() => {
+                root.set('state', rootComponent.state);
+                root.set('slots', slots);
+            });
+        }
+        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.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.syncComponentState(root, rootComponent);
+        this.syncComponentSlots(slots, rootComponent);
+    }
+    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);
+            if (focusSlot && anchorSlot) {
+                return {
+                    anchorSlot,
+                    anchorOffset: anchorPosition.index,
+                    focusSlot,
+                    focusOffset: focusPosition.index
+                };
+            }
+        }
+        return null;
+    }
+    getRelativeCursorLocation() {
+        const { anchorSlot, anchorOffset, focusSlot, focusOffset } = this.selection;
+        if (anchorSlot) {
+            const anchorYText = this.contentMap.get(anchorSlot);
+            if (anchorYText) {
+                const anchorPosition = yjs.createRelativePositionFromTypeIndex(anchorYText, anchorOffset);
+                if (focusSlot) {
+                    const focusYText = this.contentMap.get(focusSlot);
+                    if (focusYText) {
+                        const focusPosition = yjs.createRelativePositionFromTypeIndex(focusYText, focusOffset);
+                        return {
+                            focus: focusPosition,
+                            anchor: anchorPosition
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    syncSlotContent(content, slot) {
+        this.contentMap.set(slot, content);
+        const syncRemote = (ev, tr) => {
+            this.runRemoteUpdate(tr, () => {
+                slot.retain(0);
+                ev.keysChanged.forEach(key => {
+                    const change = ev.keys.get(key);
+                    if (!change) {
+                        return;
+                    }
+                    const updateType = change.action;
+                    if (updateType === 'update' || updateType === 'add') {
+                        const attribute = this.registry.getAttribute(key);
+                        if (attribute) {
+                            slot.setAttribute(attribute, content.getAttribute(key));
+                        }
+                    }
+                    else if (updateType === 'delete') {
+                        const attribute = this.registry.getAttribute(key);
+                        if (attribute) {
+                            slot.removeAttribute(attribute);
+                        }
+                    }
+                });
+                ev.delta.forEach(action => {
+                    if (Reflect.has(action, 'retain')) {
+                        if (action.attributes) {
+                            const formats = remoteFormatsToLocal(this.registry, action.attributes);
+                            if (formats.length) {
+                                slot.retain(action.retain, formats);
+                            }
+                            slot.retain(slot.index + action.retain);
+                        }
+                        else {
+                            slot.retain(action.retain);
+                        }
+                    }
+                    else if (action.insert) {
+                        const index = slot.index;
+                        let length = 1;
+                        if (typeof action.insert === 'string') {
+                            length = action.insert.length;
+                            slot.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);
+                        }
+                        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 (slot === this.selection.focusSlot && this.selection.focusOffset > index) {
+                                this.selection.setFocus(slot, this.selection.focusOffset + length);
+                            }
+                        }
+                    }
+                    else if (action.delete) {
+                        const index = slot.index;
+                        slot.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 (slot === this.selection.focusSlot && this.selection.focusOffset >= index) {
+                                this.selection.setFocus(slot, this.selection.focusOffset - action.delete);
+                            }
+                        }
+                    }
+                });
+            });
+        };
+        content.observe(syncRemote);
+        const sub = slot.onContentChange.subscribe(actions => {
+            this.runLocalUpdate(() => {
+                var _a;
+                let offset = 0;
+                let length = 0;
+                for (const action of actions) {
+                    if (action.type === 'retain') {
+                        const formats = action.formats;
+                        if (formats) {
+                            const keys = Object.keys(formats);
+                            let length = keys.length;
+                            keys.forEach(key => {
+                                const formatter = this.registry.getFormatter(key);
+                                if (!formatter) {
+                                    length--;
+                                    Reflect.deleteProperty(formats, key);
+                                }
+                            });
+                            if (length) {
+                                content.format(offset, action.offset, formats);
+                            }
+                        }
+                        else {
+                            offset = action.offset;
+                        }
+                    }
+                    else if (action.type === 'insert') {
+                        const delta = content.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 || {});
+                        }
+                        else {
+                            length = 1;
+                            const sharedComponent = this.createSharedComponentByComponent(action.ref);
+                            content.insertEmbed(offset, sharedComponent, action.formats || {});
+                        }
+                        if (isEmpty && offset === 0) {
+                            content.delete(content.length - 1, 1);
+                        }
+                        offset += length;
+                    }
+                    else if (action.type === 'delete') {
+                        const delta = content.toDelta();
+                        if (content.length) {
+                            content.delete(offset, action.count);
+                        }
+                        if (content.length === 0) {
+                            content.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);
+                    }
+                    else if (action.type === 'attrRemove') {
+                        content.removeAttribute(action.name);
+                    }
+                }
+            });
+        });
+        sub.add(slot.onChildComponentRemove.subscribe(components => {
+            components.forEach(c => {
+                this.cleanSubscriptionsByComponent(c);
+            });
+        }));
+        this.contentSyncCaches.set(slot, () => {
+            content.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;
+                            }
+                        });
+                    }
+                });
+            });
+        };
+        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 => {
+                    if (Reflect.has(action, 'retain')) {
+                        index += action.retain;
+                        slots.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);
+                            index++;
+                        });
+                    }
+                    else if (action.delete) {
+                        slots.retain(index);
+                        slots.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);
+            sub.unsubscribe();
+        });
+    }
+    syncComponentState(remoteComponent, component) {
+        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;
+                            }
+                        });
+                    }
+                });
+            });
+        };
+        remoteComponent.observe(syncRemote);
+        const sub = component.onStateChange.subscribe(change => {
+            this.runLocalUpdate(() => {
+                remoteComponent.set('state', change.newState);
+            }, change.record);
+        });
+        this.componentStateSyncCaches.set(component, () => {
+            remoteComponent.unobserve(syncRemote);
+            sub.unsubscribe();
+        });
+    }
+    runLocalUpdate(fn, record = true) {
+        if (this.updateFromRemote || this.controller.readonly) {
+            return;
+        }
+        this.updateRemoteActions.push({
+            record,
+            action: fn
+        });
+    }
+    runRemoteUpdate(tr, fn) {
+        if (tr.origin === this.yDoc) {
+            return;
+        }
+        this.updateFromRemote = true;
+        if (tr.origin === this.manager) {
+            this.scheduler.historyApplyTransact(fn);
+        }
+        else {
+            this.scheduler.remoteUpdateTransact(fn);
+        }
+        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([
+    di.Injectable(),
+    __param(0, di.Inject(core.HISTORY_STACK_SIZE)),
+    __param(7, di.Optional()),
+    __metadata("design:paramtypes", [Number, core.RootComponentRef,
+        core.Controller,
+        core.Scheduler,
+        core.Registry,
+        core.Selection,
+        core.Starter,
+        CustomUndoManagerConfig])
+], exports.Collaborate);
+function remoteFormatsToLocal(registry, attrs) {
+    const formats = [];
+    if (attrs) {
+        Object.keys(attrs).forEach(key => {
+            const formatter = registry.getFormatter(key);
+            if (formatter) {
+                formats.push([formatter, attrs[key]]);
+            }
+        });
+    }
+    return formats;
+}
+
+const collaborateModule = {
+    providers: [
+        exports.Collaborate,
+        {
+            provide: core.History,
+            useExisting: exports.Collaborate
+        }
+    ]
+};
+
+exports.CustomUndoManagerConfig = CustomUndoManagerConfig;
+exports.collaborateModule = collaborateModule;