@textbus/collaborate 2.0.0-beta.1 → 2.0.0-beta.12

package/src/{collab/collaborate-cursor.ts → collaborate-cursor.ts}

@@ -1,7 +1,6 @@
-import { Inject, Injectable } from '@tanbo/di'
+import { Inject, Injectable, Optional } from '@tanbo/di'
 import {
   createElement,
-  EDITABLE_DOCUMENT,
   EDITOR_CONTAINER,
   getLayoutRectByRange,
   SelectionBridge
@@ -15,21 +14,28 @@ export interface RemoteSelection {
   paths: SelectionPaths
 }
 
-export interface SelectionRect {
-  color: string
-  username: string
+export interface Rect {
   x: number
   y: number
   width: number
   height: number
 }
 
+export interface SelectionRect extends Rect {
+  color: string
+  username: string
+}
+
 export interface RemoteSelectionCursor {
   cursor: HTMLElement
   anchor: HTMLElement
   userTip: HTMLElement
 }
 
+export abstract class CollaborateCursorAwarenessDelegate {
+  abstract getRects(selection: Selection, nativeRange: Range): false | Rect[]
+}
+
 @Injectable()
 export class CollaborateCursor {
   private canvas = createElement('canvas', {
@@ -60,7 +66,7 @@ export class CollaborateCursor {
   private onRectsChange = new Subject<SelectionRect[]>()
 
   constructor(@Inject(EDITOR_CONTAINER) private container: HTMLElement,
-              @Inject(EDITABLE_DOCUMENT) private document: Document,
+              @Optional() private awarenessDelegate: CollaborateCursorAwarenessDelegate,
               private nativeSelection: SelectionBridge,
               private selection: Selection) {
     container.prepend(this.canvas, this.tooltips)
@@ -85,55 +91,68 @@ export class CollaborateCursor {
 
 
     paths.filter(i => {
-      return i.paths.start.length && i.paths.end.length
+      return i.paths.anchor.length && i.paths.focus.length
     }).forEach(item => {
-      const startOffset = item.paths.start.pop()!
-      const startSlot = this.selection.findSlotByPaths(item.paths.start)
-      const endOffset = item.paths.end.pop()!
-      const endSlot = this.selection.findSlotByPaths(item.paths.end)
-
-      if (startSlot && endSlot) {
-        const position = this.nativeSelection.getPositionByRange({
-          startOffset,
-          endOffset,
-          startSlot,
-          endSlot
+      const anchorOffset = item.paths.anchor.pop()!
+      const anchorSlot = this.selection.findSlotByPaths(item.paths.anchor)
+      const focusOffset = item.paths.focus.pop()!
+      const focusSlot = this.selection.findSlotByPaths(item.paths.focus)
+      if (!anchorSlot || !focusSlot) {
+        return
+      }
+
+      const {focus, anchor} = this.nativeSelection.getPositionByRange({
+        focusOffset,
+        anchorOffset,
+        focusSlot,
+        anchorSlot
+      })
+      if (!focus || !anchor) {
+        return
+      }
+      const nativeRange = document.createRange()
+      nativeRange.setStart(anchor.node, anchor.offset)
+      nativeRange.setEnd(focus.node, focus.offset)
+      if ((anchor.node !== focus.node || anchor.offset !== focus.offset) && nativeRange.collapsed) {
+        nativeRange.setStart(focus.node, focus.offset)
+        nativeRange.setEnd(anchor.node, anchor.offset)
+      }
+
+      let rects: Rect[] | DOMRectList | false = false
+      if (this.awarenessDelegate) {
+        rects = this.awarenessDelegate.getRects(this.selection, nativeRange)
+      }
+      if (!rects) {
+        rects = nativeRange.getClientRects()
+      }
+      const selectionRects: SelectionRect[] = []
+      for (let i = rects.length - 1; i >= 0; i--) {
+        const rect = rects[i]
+        selectionRects.push({
+          color: item.color,
+          username: item.username,
+          x: rect.x - containerRect.x,
+          y: rect.y - containerRect.y,
+          width: rect.width,
+          height: rect.height,
         })
-        if (position.start && position.end) {
-          const nativeRange = this.document.createRange()
-          nativeRange.setStart(position.start.node, position.start.offset)
-          nativeRange.setEnd(position.end.node, position.end.offset)
-
-          const rects = nativeRange.getClientRects()
-          const selectionRects: SelectionRect[] = []
-          for (let i = rects.length - 1; i >= 0; i--) {
-            const rect = rects[i]
-            selectionRects.push({
-              color: item.color,
-              username: item.username,
-              x: rect.x - containerRect.x,
-              y: rect.y - containerRect.y,
-              width: rect.width,
-              height: rect.height,
-            })
-          }
-          this.onRectsChange.next(selectionRects)
-
-          const cursorRange = nativeRange.cloneRange()
-          cursorRange.collapse(!item.paths.focusEnd)
-
-          const cursorRect = getLayoutRectByRange(cursorRange)
-
-          users.push({
-            username: item.username,
-            color: item.color,
-            x: cursorRect.x - containerRect.x,
-            y: cursorRect.y - containerRect.y,
-            width: 2,
-            height: cursorRect.height
-          })
-        }
       }
+      this.onRectsChange.next(selectionRects)
+
+      const cursorRange = nativeRange.cloneRange()
+      cursorRange.setStart(focus.node, focus.offset)
+      cursorRange.collapse(true)
+
+      const cursorRect = getLayoutRectByRange(cursorRange)
+
+      users.push({
+        username: item.username,
+        color: item.color,
+        x: cursorRect.x - containerRect.x,
+        y: cursorRect.y - containerRect.y,
+        width: 2,
+        height: cursorRect.height
+      })
     })
     this.drawUserCursor(users)
   }

package/src/collaborate.ts

@@ -1,24 +1,24 @@
 import { Injectable } from '@tanbo/di'
-import { merge, microTask, Observable, Subject, Subscription } from '@tanbo/stream'
+import { Observable, Subject, Subscription } from '@tanbo/stream'
 import {
-  RootComponentRef,
-  Starter,
-  Translator,
+  ComponentInstance,
+  ContentType,
+  Formats,
+  History,
+  makeError,
   Registry,
+  RootComponentRef,
+  Scheduler,
   Selection,
   SelectionPaths,
-  History, Renderer, Slot, ComponentInstance, makeError, Formats
+  Slot,
+  Starter,
+  Translator
 } from '@textbus/core'
-import {
-  Doc as YDoc,
-  Map as YMap,
-  Text as YText,
-  Array as YArray,
-  UndoManager,
-  Transaction
-} from 'yjs'
+import { Array as YArray, Doc as YDoc, Map as YMap, Text as YText, Transaction, UndoManager } from 'yjs'
 
-import { CollaborateCursor, RemoteSelection } from './collab/_api'
+import { CollaborateCursor, RemoteSelection } from './collaborate-cursor'
+import { createUnknownComponent } from './unknown.component'
 
 const collaborateErrorFn = makeError('Collaborate')
 
@@ -60,8 +60,8 @@ export class Collaborate implements History {
 
   constructor(private rootComponentRef: RootComponentRef,
               private collaborateCursor: CollaborateCursor,
+              private scheduler: Scheduler,
               private translator: Translator,
-              private renderer: Renderer,
               private registry: Registry,
               private selection: Selection,
               private starter: Starter) {
@@ -74,9 +74,6 @@ export class Collaborate implements History {
 
   setup() {
     this.subscriptions.push(
-      this.starter.onReady.subscribe(() => {
-        this.listen2()
-      }),
       this.selection.onChange.subscribe(() => {
         const paths = this.selection.getPaths()
         this.selectionChangeEvent.next(paths)
@@ -89,18 +86,22 @@ export class Collaborate implements History {
   }
 
   listen() {
-    //
+    this.syncRootComponent()
   }
 
   back() {
     if (this.canBack) {
+      this.scheduler.ignoreChanges = true
       this.manager.undo()
+      this.scheduler.ignoreChanges = false
     }
   }
 
   forward() {
     if (this.canForward) {
+      this.scheduler.ignoreChanges = true
       this.manager.redo()
+      this.scheduler.ignoreChanges = false
     }
   }
 
@@ -108,7 +109,7 @@ export class Collaborate implements History {
     this.subscriptions.forEach(i => i.unsubscribe())
   }
 
-  private listen2() {
+  private syncRootComponent() {
     const root = this.yDoc.getText('content')
     const rootComponent = this.rootComponentRef.component!
     this.manager = new UndoManager(root, {
@@ -117,20 +118,13 @@ export class Collaborate implements History {
     this.syncContent(root, rootComponent.slots.get(0)!)
 
     this.subscriptions.push(
-      merge(
-        rootComponent.changeMarker.onForceChange,
-        rootComponent.changeMarker.onChange
-      ).pipe(
-        microTask()
-      ).subscribe(() => {
+      this.scheduler.onDocChange.subscribe(() => {
         this.yDoc.transact(() => {
           this.updateRemoteActions.forEach(fn => {
             fn()
           })
           this.updateRemoteActions = []
         }, this.yDoc)
-        this.renderer.render()
-        this.selection.restore()
       })
     )
   }
@@ -141,7 +135,14 @@ export class Collaborate implements History {
         slot.retain(0)
         ev.delta.forEach(action => {
           if (Reflect.has(action, 'retain')) {
-            slot.retain(action.retain!, makeFormats(this.registry, action.attributes))
+            if (action.attributes) {
+              const formats = makeFormats(this.registry, action.attributes)
+              if (formats.length) {
+                slot.retain(action.retain!, formats)
+              }
+            } else {
+              slot.retain(action.retain)
+            }
           } else if (action.insert) {
             const index = slot.index
             let length = 1
@@ -150,17 +151,18 @@ export class Collaborate implements History {
               slot.insert(action.insert, makeFormats(this.registry, action.attributes))
             } else {
               const sharedComponent = action.insert as YMap<any>
-              const component = this.createComponentBySharedComponent(sharedComponent)
+              const canInsertInlineComponent = slot.schema.includes(ContentType.InlineComponent)
+              const component = this.createComponentBySharedComponent(sharedComponent, canInsertInlineComponent)
               this.syncSlots(sharedComponent.get('slots'), component)
               this.syncComponent(sharedComponent, component)
               slot.insert(component)
             }
             if (this.selection.isSelected) {
-              if (slot === this.selection.startSlot && this.selection.startOffset! >= index) {
-                this.selection.setStart(slot, this.selection.startOffset! + length)
+              if (slot === this.selection.anchorSlot && this.selection.anchorOffset! > index) {
+                this.selection.setAnchor(slot, this.selection.anchorOffset! + length)
               }
-              if (slot === this.selection.endSlot && this.selection.endOffset! >= index) {
-                this.selection.setEnd(slot, this.selection.endOffset! + length)
+              if (slot === this.selection.focusSlot && this.selection.focusOffset! > index) {
+                this.selection.setFocus(slot, this.selection.focusOffset! + length)
               }
             }
           } else if (action.delete) {
@@ -168,11 +170,11 @@ export class Collaborate implements History {
             slot.retain(slot.index)
             slot.delete(action.delete)
             if (this.selection.isSelected) {
-              if (slot === this.selection.startSlot && this.selection.startOffset! >= index) {
-                this.selection.setStart(slot, this.selection.startOffset! - action.delete)
+              if (slot === this.selection.anchorSlot && this.selection.anchorOffset! >= index) {
+                this.selection.setAnchor(slot, this.selection.startOffset! - action.delete)
               }
-              if (slot === this.selection.endSlot && this.selection.endOffset! >= index) {
-                this.selection.setEnd(slot, this.selection.endOffset! - action.delete)
+              if (slot === this.selection.focusSlot && this.selection.focusOffset! >= index) {
+                this.selection.setFocus(slot, this.selection.focusOffset! - action.delete)
               }
             }
           } else if (action.attributes) {
@@ -191,8 +193,19 @@ export class Collaborate implements History {
         let length = 0
         for (const action of actions) {
           if (action.type === 'retain') {
-            if (action.formats) {
-              content.format(offset, action.offset, action.formats)
+            const formats = action.formats
+            if (formats) {
+              const keys = Object.keys(formats)
+              let length = keys.length
+              keys.forEach(key => {
+                if (!this.registry.getFormatter(key)) {
+                  length--
+                  Reflect.deleteProperty(formats, key)
+                }
+              })
+              if (length) {
+                content.format(offset, action.offset, formats)
+              }
             } else {
               offset = action.offset
             }
@@ -201,16 +214,14 @@ export class Collaborate implements History {
             const isEmpty = delta.length === 1 && delta[0].insert === Slot.emptyPlaceholder
             if (typeof action.content === 'string') {
               length = action.content.length
-              content.insert(offset, action.content)
+              content.insert(offset, action.content, action.formats || {})
             } else {
               length = 1
               const component = slot.getContentAtIndex(offset) as ComponentInstance
               const sharedComponent = this.createSharedComponentByComponent(component)
               content.insertEmbed(offset, sharedComponent)
             }
-            if (action.formats) {
-              content.format(offset, length, action.formats)
-            }
+
             if (isEmpty && offset === 0) {
               content.delete(content.length - 1, 1)
             }
@@ -225,6 +236,12 @@ export class Collaborate implements History {
         }
       })
     })
+
+    sub.add(slot.onChildComponentRemove.subscribe(components => {
+      components.forEach(c => {
+        this.cleanSubscriptionsByComponent(c)
+      })
+    }))
     this.contentSyncCaches.set(slot, () => {
       content.unobserve(syncRemote)
       sub.unsubscribe()
@@ -263,18 +280,21 @@ export class Collaborate implements History {
     const slots = component.slots
     const syncRemote = (ev, tr) => {
       this.runRemoteUpdate(tr, () => {
+        let index = 0
         ev.delta.forEach(action => {
           if (Reflect.has(action, 'retain')) {
             slots.retain(action.retain!)
+            index += action.retain
           } else if (action.insert) {
             (action.insert as Array<YMap<any>>).forEach(item => {
               const slot = this.createSlotBySharedSlot(item)
               slots.insert(slot)
               this.syncContent(item.get('content'), slot)
               this.syncSlot(item, slot)
+              index++
             })
           } else if (action.delete) {
-            slots.retain(slots.index)
+            slots.retain(index)
             slots.delete(action.delete)
           }
         })
@@ -295,15 +315,18 @@ export class Collaborate implements History {
             remoteSlots.insert(index, [sharedSlot])
             index++
           } else if (action.type === 'delete') {
-            slots.slice(index, index + action.count).forEach(slot => {
-              this.cleanSubscriptionsBySlot(slot)
-            })
             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()
@@ -396,7 +419,7 @@ export class Collaborate implements History {
     return sharedSlot
   }
 
-  private createComponentBySharedComponent(yMap: YMap<any>): ComponentInstance {
+  private createComponentBySharedComponent(yMap: YMap<any>, canInsertInlineComponent: boolean): ComponentInstance {
     const sharedSlots = yMap.get('slots') as YArray<YMap<any>>
     const slots: Slot[] = []
     sharedSlots.forEach(sharedSlot => {
@@ -410,13 +433,17 @@ export class Collaborate implements History {
     })
     if (instance) {
       instance.slots.toArray().forEach((slot, index) => {
-        const sharedSlot = sharedSlots.get(index)
+        let sharedSlot = sharedSlots.get(index)
+        if (!sharedSlot) {
+          sharedSlot = this.createSharedSlotBySlot(slot)
+          sharedSlots.push([sharedSlot])
+        }
         this.syncSlot(sharedSlot, slot)
         this.syncContent(sharedSlot.get('content'), slot)
       })
       return instance
     }
-    throw collaborateErrorFn(`cannot find component factory \`${name}\`.`)
+    return createUnknownComponent(name, canInsertInlineComponent).createInstance(this.starter)
   }
 
   private createSlotBySharedSlot(sharedSlot: YMap<any>): Slot {
@@ -436,7 +463,8 @@ export class Collaborate implements History {
           slot.insert(action.insert, makeFormats(this.registry, action.attributes))
         } else {
           const sharedComponent = action.insert as YMap<any>
-          const component = this.createComponentBySharedComponent(sharedComponent)
+          const canInsertInlineComponent = slot.schema.includes(ContentType.InlineComponent)
+          const component = this.createComponentBySharedComponent(sharedComponent, canInsertInlineComponent)
           slot.insert(component)
           this.syncSlots(sharedComponent.get('slots'), component)
           this.syncComponent(sharedComponent, component)

package/src/public-api.ts

@@ -1,2 +1,18 @@
-export * from './collab/_api'
+import { History, Module } from '@textbus/core'
+
+import { Collaborate } from './collaborate'
+import { CollaborateCursor } from './collaborate-cursor'
+
 export * from './collaborate'
+export * from './collaborate-cursor'
+
+export const collaborateModule: Module = {
+  providers: [
+    Collaborate,
+    CollaborateCursor,
+    {
+      provide: History,
+      useClass: Collaborate
+    }
+  ]
+}

package/src/unknown.component.ts

@@ -0,0 +1,22 @@
+import { ContentType, defineComponent, VElement } from '@textbus/core'
+
+export function createUnknownComponent(factoryName: string, canInsertInlineComponent: boolean) {
+  const unknownComponent = defineComponent({
+    type: canInsertInlineComponent ? ContentType.InlineComponent : ContentType.BlockComponent,
+    name: 'UnknownComponent',
+    setup() {
+      console.error(`cannot find component factory \`${factoryName}\`.`)
+      return {
+        render() {
+          return VElement.createElement('textbus-unknown-component', {
+            style: {
+              display: canInsertInlineComponent ? 'inline' : 'block',
+              color: '#f00'
+            }
+          }, unknownComponent.name)
+        }
+      }
+    }
+  })
+  return unknownComponent
+}

package/bundles/collab/_api.d.ts

@@ -1 +0,0 @@
-export * from './collaborate-cursor';

package/bundles/collab/_api.js

@@ -1,2 +0,0 @@
-export * from './collaborate-cursor';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb2xsYWIvX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb2xsYWJvcmF0ZS1jdXJzb3InXG4iXX0=