@textbus/collaborate 5.1.5 → 5.2.0

package/dist/index.esm.js

@@ -0,0 +1,959 @@
+import { Injectable as w, Inject as $, Optional as Y } from "@viewfly/core";
+import { makeError as x, HISTORY_STACK_SIZE as H, ChangeOrigin as q, Slot as m, observe as T, AsyncSlot as R, AsyncComponent as D, Component as N, History as L, Selection as j } from "@textbus/core";
+import { Subject as l, map as K, filter as Z, Subscription as _ } from "@tanbo/stream";
+import { UndoManager as b, Doc as G, createAbsolutePositionFromRelativePosition as P, createRelativePositionFromTypeIndex as O, Map as S, Array as F, Text as v } from "yjs";
+import { HocuspocusProvider as J } from "@hocuspocus/provider";
+import { WebsocketProvider as Q } from "y-websocket";
+var V = Object.getOwnPropertyDescriptor, X = (t, e, s, n) => {
+  for (var o = n > 1 ? void 0 : n ? V(e, s) : e, r = t.length - 1, a; r >= 0; r--)
+    (a = t[r]) && (o = a(o) || o);
+  return o;
+}, I = (t, e) => (s, n) => e(s, n, t);
+class pe {
+}
+const ee = x("CollabHistory");
+let E = class {
+  constructor(t, e, s, n, o) {
+    this.rootComponentRef = t, this.collaborate = e, this.scheduler = s, this.stackSize = n, this.undoManagerConfig = o, this.onBack = this.backEvent.asObservable(), this.onForward = this.forwardEvent.asObservable(), this.onChange = this.changeEvent.asObservable(), this.onPush = this.pushEvent.asObservable();
+  }
+  rootComponentRef;
+  collaborate;
+  scheduler;
+  stackSize;
+  undoManagerConfig;
+  onBack;
+  onForward;
+  onChange;
+  onPush;
+  get canBack() {
+    return this.manager?.canUndo() || !1;
+  }
+  get canForward() {
+    return this.manager?.canRedo() || !1;
+  }
+  manager = null;
+  historyItems = [];
+  index = 0;
+  subscriptions = [];
+  backEvent = new l();
+  forwardEvent = new l();
+  changeEvent = new l();
+  pushEvent = new l();
+  listen() {
+    const t = this.collaborate.yDoc.getMap("RootComponent"), e = this.rootComponentRef.component;
+    this.collaborate.syncRootComponent(this.collaborate.yDoc, t, e);
+    const s = this.undoManagerConfig || {}, n = new b(t, {
+      trackedOrigins: /* @__PURE__ */ new Set([this.collaborate.yDoc]),
+      captureTransaction(r) {
+        return s.captureTransaction ? s.captureTransaction(r) : !0;
+      },
+      deleteFilter(r) {
+        return s.deleteFilter ? s.deleteFilter(r) : !0;
+      }
+    });
+    this.manager = n;
+    let o = null;
+    this.subscriptions.push(
+      this.scheduler.onLocalChangeBefore.subscribe(() => {
+        o = this.collaborate.getRelativeCursorLocation();
+      }),
+      this.collaborate.onAddSubModel.subscribe(() => {
+        throw ee("single document does not support submodels.");
+      })
+    ), n.on("stack-item-added", (r) => {
+      r.type === "undo" ? r.origin === n ? this.index++ : (this.historyItems.length = this.index, this.historyItems.push({
+        before: o,
+        after: this.collaborate.getRelativeCursorLocation()
+      }), this.index++) : this.index--, n.undoStack.length > this.stackSize && (this.historyItems.shift(), n.undoStack.shift()), r.origin === this.collaborate.yDoc && this.pushEvent.next(), this.changeEvent.next();
+    }), n.on("stack-item-popped", (r) => {
+      const a = r.type === "undo" ? this.index : this.index - 1, i = this.historyItems[a] || null, c = r.type === "undo" ? i?.before : i?.after;
+      this.collaborate.restoreCursorPosition(c);
+    });
+  }
+  back() {
+    this.canBack && (this.manager?.undo(), this.backEvent.next());
+  }
+  forward() {
+    this.canForward && (this.manager?.redo(), this.forwardEvent.next());
+  }
+  clear() {
+    const t = this.historyItems.pop();
+    this.historyItems = t ? [t] : [], this.index = t ? 1 : 0, this.manager?.clear(), this.changeEvent.next();
+  }
+  destroy() {
+    this.index = 0, this.historyItems = [], this.subscriptions.forEach((t) => t.unsubscribe()), this.manager && (this.manager.destroy(), this.manager.captureTransaction = () => !0, this.manager.deleteFilter = () => !0, this.manager.trackedOrigins = /* @__PURE__ */ new Set([null])), this.manager = null;
+  }
+};
+E = X([
+  w(),
+  I(3, $(H)),
+  I(4, Y())
+], E);
+var te = Object.getOwnPropertyDescriptor, se = (t, e, s, n) => {
+  for (var o = n > 1 ? void 0 : n ? te(e, s) : e, r = t.length - 1, a; r >= 0; r--)
+    (a = t[r]) && (o = a(o) || o);
+  return o;
+};
+const g = x("Collaborate");
+class ne {
+  slotAndYTextMap = /* @__PURE__ */ new WeakMap();
+  yTextAndSlotMap = /* @__PURE__ */ new WeakMap();
+  set(e, s) {
+    e instanceof m ? (this.slotAndYTextMap.set(e, s), this.yTextAndSlotMap.set(s, e)) : (this.slotAndYTextMap.set(s, e), this.yTextAndSlotMap.set(e, s));
+  }
+  get(e) {
+    return e instanceof m ? this.slotAndYTextMap.get(e) || null : this.yTextAndSlotMap.get(e) || null;
+  }
+  delete(e) {
+    if (e instanceof m) {
+      const s = this.slotAndYTextMap.get(e);
+      this.slotAndYTextMap.delete(e), s && this.yTextAndSlotMap.delete(s);
+    } else {
+      const s = this.yTextAndSlotMap.get(e);
+      this.yTextAndSlotMap.delete(e), s && this.slotAndYTextMap.delete(s);
+    }
+  }
+}
+let f = class {
+  constructor(t, e, s, n) {
+    this.scheduler = t, this.registry = e, this.selection = s, this.subModelLoader = n, this.onAddSubModel = this.addSubModelEvent.asObservable();
+  }
+  scheduler;
+  registry;
+  selection;
+  subModelLoader;
+  yDoc = new G();
+  slotMap = new ne();
+  onAddSubModel;
+  subscriptions = [];
+  updateFromRemote = !1;
+  addSubModelEvent = new l();
+  updateRemoteActions = /* @__PURE__ */ new WeakMap();
+  noRecord = {};
+  syncRootComponent(t, e, s) {
+    this.initSyncEvent(t), this.syncComponent(t, e, s);
+  }
+  syncRootSlot(t, e, s) {
+    e.length ? (s.retain(0), s.delete(s.length), s.cleanAttributes(), s.cleanFormats(), this.initLocalSlotBySharedSlot(e, s)) : t.transact(() => {
+      this.initSharedSlotByLocalSlot(e, s);
+    }), this.initSyncEvent(t), this.syncSlot(e, s);
+  }
+  getAbstractSelection(t) {
+    const e = P(t.anchor.position, t.anchor.doc), s = P(t.focus.position, t.focus.doc);
+    if (e && s) {
+      const n = this.slotMap.get(s.type), o = this.slotMap.get(e.type);
+      if (n && o)
+        return {
+          anchorSlot: o,
+          anchorOffset: e.index,
+          focusSlot: n,
+          focusOffset: s.index
+        };
+    }
+    return null;
+  }
+  getRelativeCursorLocation() {
+    const { anchorSlot: t, anchorOffset: e, focusSlot: s, focusOffset: n } = this.selection;
+    if (t) {
+      const o = this.slotMap.get(t);
+      if (o) {
+        const r = O(o, e);
+        if (s) {
+          const a = this.slotMap.get(s);
+          if (a) {
+            const i = O(a, n);
+            return {
+              focus: {
+                doc: a.doc,
+                position: i
+              },
+              anchor: {
+                doc: o.doc,
+                position: r
+              }
+            };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  restoreCursorPosition(t) {
+    if (!t) {
+      this.selection.unSelect();
+      return;
+    }
+    const e = this.getAbstractSelection(t);
+    e && this.selection.setBaseAndExtent(
+      e.anchorSlot,
+      e.anchorOffset,
+      e.focusSlot,
+      e.focusOffset
+    );
+  }
+  initSyncEvent(t) {
+    this.subscriptions.push(
+      this.scheduler.onDocChanged.pipe(
+        K((e) => e.filter((s) => s.from !== q.Remote)),
+        Z((e) => e.length)
+      ).subscribe(() => {
+        const e = [];
+        let s = null;
+        const n = this.updateRemoteActions.get(t) || [];
+        for (const o of n)
+          s || (s = {
+            record: o.record,
+            actions: []
+          }, e.push(s)), s.record === o.record ? s.actions.push(o.action) : (s = {
+            record: o.record,
+            actions: [o.action]
+          }, e.push(s));
+        this.updateRemoteActions.delete(t);
+        for (const o of e)
+          t.transact(() => {
+            o.actions.forEach((r) => {
+              r();
+            });
+          }, o.record ? t : this.noRecord);
+      })
+    );
+  }
+  syncComponent(t, e, s) {
+    let n = e.get("state");
+    n ? (Object.keys(s.state).forEach((o) => {
+      Reflect.deleteProperty(s.state, o);
+    }), this.syncSharedMapToLocalMap(n, s.state)) : (n = new S(), this.syncLocalMapToSharedMap(s.state, n), t.transact(() => {
+      e.set("state", n);
+    }));
+  }
+  syncSlot(t, e) {
+    const s = (o, r) => {
+      this.runRemoteUpdate(r, () => {
+        e.retain(0), o.keysChanged.forEach((a) => {
+          const i = o.keys.get(a);
+          if (!i)
+            return;
+          const c = i.action;
+          if (c === "update" || c === "add") {
+            const h = this.registry.getAttribute(a);
+            h && e.setAttribute(h, t.getAttribute(a));
+          } else if (c === "delete") {
+            const h = this.registry.getAttribute(a);
+            h && e.removeAttribute(h);
+          }
+        }), o.delta.forEach((a) => {
+          if (Reflect.has(a, "retain")) {
+            if (a.attributes) {
+              const i = C(this.registry, a.attributes);
+              i.length && e.retain(a.retain, i);
+            }
+            e.retain(e.index + a.retain);
+          } else if (a.insert) {
+            const i = e.index;
+            let c = 1;
+            if (typeof a.insert == "string")
+              c = a.insert.length, e.insert(a.insert, C(this.registry, a.attributes));
+            else {
+              const h = a.insert, d = this.createLocalComponentBySharedComponent(h);
+              e.insert(d);
+            }
+            this.selection.isSelected && !(r.origin instanceof b) && (e === this.selection.anchorSlot && this.selection.anchorOffset > i && this.selection.setAnchor(e, this.selection.anchorOffset + c), e === this.selection.focusSlot && this.selection.focusOffset > i && this.selection.setFocus(e, this.selection.focusOffset + c));
+          } else if (a.delete) {
+            const i = e.index;
+            e.delete(a.delete), this.selection.isSelected && !(r.origin instanceof b) && (e === this.selection.anchorSlot && this.selection.anchorOffset >= i && this.selection.setAnchor(e, this.selection.startOffset - a.delete), e === this.selection.focusSlot && this.selection.focusOffset >= i && this.selection.setFocus(e, this.selection.focusOffset - a.delete));
+          }
+        });
+      });
+    };
+    t.observe(s);
+    const n = e.onContentChange.subscribe((o) => {
+      this.runLocalUpdate(t.doc, !0, () => {
+        let r = 0, a = 0;
+        for (const i of o)
+          if (i.type === "retain") {
+            const c = i.formats;
+            if (c) {
+              const h = Object.keys(c);
+              let d = h.length;
+              h.forEach((u) => {
+                this.registry.getFormatter(u) || (d--, Reflect.deleteProperty(c, u));
+              }), d && t.format(r, i.offset, c);
+            } else
+              r = i.offset;
+          } else if (i.type === "contentInsert") {
+            const c = t.toDelta(), h = c.length === 1 && c[0].insert === m.emptyPlaceholder;
+            if (typeof i.content == "string")
+              a = i.content.length, t.insert(r, i.content, i.formats || {});
+            else {
+              a = 1;
+              const d = this.createSharedComponentByLocalComponent(i.ref);
+              t.insertEmbed(r, d, i.formats || {});
+            }
+            h && r === 0 && t.delete(t.length - 1, 1), r += a;
+          } else if (i.type === "delete") {
+            const c = t.toDelta();
+            t.length && t.delete(r, i.count), t.length === 0 && t.insert(0, `
+`, c[0]?.attributes);
+          } else i.type === "attrSet" ? t.setAttribute(i.name, i.value) : i.type === "attrDelete" && t.removeAttribute(i.name);
+      });
+    });
+    this.slotMap.set(e, t), e.__changeMarker__.addDetachCallback(() => {
+      this.slotMap.delete(e), t.unobserve(s), n.unsubscribe();
+    });
+  }
+  destroy() {
+    this.subscriptions.forEach((t) => t.unsubscribe()), this.subscriptions = [];
+  }
+  syncSharedMapToLocalMap(t, e) {
+    t.forEach((s, n) => {
+      e[n] = this.createLocalModelBySharedByModel(s);
+    }), this.syncObject(t, e);
+  }
+  createLocalMapBySharedMap(t) {
+    const e = T({});
+    return this.syncSharedMapToLocalMap(t, e), e;
+  }
+  createLocalArrayBySharedArray(t) {
+    const e = T([]);
+    return e.push(...t.map((s) => this.createLocalModelBySharedByModel(s))), this.syncArray(t, e), e;
+  }
+  syncLocalMapToSharedMap(t, e) {
+    Object.entries(t).forEach(([s, n]) => {
+      e.set(s, this.createSharedModelByLocalModel(n));
+    }), this.syncObject(e, t);
+  }
+  createSharedMapByLocalMap(t) {
+    const e = new S();
+    return this.syncLocalMapToSharedMap(t, e), e;
+  }
+  createSharedArrayByLocalArray(t) {
+    const e = new F();
+    return t.forEach((s) => {
+      e.push([this.createSharedModelByLocalModel(s)]);
+    }), this.syncArray(e, t), e;
+  }
+  createSharedSlotByLocalSlot(t) {
+    const e = new v(), s = t instanceof R;
+    if (e.setAttribute("schema", [...t.schema]), e.setAttribute("type", s ? "async" : "sync"), s) {
+      let r = !1;
+      const a = this.createSharedMapByLocalMap(t.metadata);
+      return e.setAttribute("metadata", a), this.subModelLoader.createSubModelBySlot(t).then((i) => {
+        if (r)
+          return;
+        const c = i.getText("content"), h = i.getMap("state");
+        this.syncLocalMapToSharedMap(t.state, h), this.initSharedSlotByLocalSlot(c, t), this.syncSlot(c, t), this.addSubModelEvent.next({
+          yDoc: i,
+          yType: c
+        }), this.initSyncEvent(i), t.loader.markAsLoaded();
+      }), t.__changeMarker__.addDetachCallback(() => {
+        r = !0;
+      }), e;
+    }
+    const n = new S();
+    this.syncLocalMapToSharedMap(t.state, n), e.setAttribute("state", n);
+    const o = new v();
+    return this.initSharedSlotByLocalSlot(o, t), e.insertEmbed(0, o), this.syncSlot(o, t), e;
+  }
+  initSharedSlotByLocalSlot(t, e) {
+    let s = 0;
+    e.toDelta().forEach((n) => {
+      let o = {};
+      if (n.formats ? n.formats.forEach((r) => {
+        o[r[0].name] = r[1];
+      }) : o = null, typeof n.insert == "string")
+        t.insert(s, n.insert, o);
+      else {
+        const r = this.createSharedComponentByLocalComponent(n.insert);
+        t.insertEmbed(s, r, o);
+      }
+      s += n.insert.length;
+    }), e.getAttributes().forEach((n) => {
+      t.setAttribute(n[0].name, n[1]);
+    });
+  }
+  createLocalSlotBySharedSlot(t) {
+    const e = t.getAttribute("type"), s = t.getAttribute("schema");
+    if (e === "async") {
+      const i = t.getAttribute("metadata"), c = new R(s || [], {}, {});
+      this.syncSharedMapToLocalMap(i, c.metadata);
+      const h = this.subModelLoader.getLoadedModelBySlot(c);
+      if (h) {
+        const u = h.getText("content"), M = h.getMap("state");
+        return this.syncSharedMapToLocalMap(M, c.state), this.syncRootSlot(h, u, c), this.addSubModelEvent.next({
+          yDoc: h,
+          yType: u
+        }), c.loader.markAsLoaded(), c;
+      }
+      let d = !1;
+      return c.loader.onRequestLoad.toPromise().then(() => this.subModelLoader.loadSubModelBySlot(c)).then((u) => {
+        if (d)
+          return;
+        const M = u.getText("content"), W = u.getMap("state");
+        this.syncSharedMapToLocalMap(W, c.state), this.syncRootSlot(u, M, c), this.addSubModelEvent.next({
+          yDoc: u,
+          yType: M
+        }), c.loader.markAsLoaded();
+      }), c.__changeMarker__.addDetachCallback(() => {
+        d = !0;
+      }), c;
+    }
+    const o = t.toDelta()[0]?.insert;
+    if (!(o instanceof v))
+      throw g("shared slot content type is not `YText`.");
+    const r = new m(s || [], {}), a = t.getAttribute("state");
+    return this.syncSharedMapToLocalMap(a, r.state), this.initLocalSlotBySharedSlot(o, r), this.syncSlot(o, r), r;
+  }
+  initLocalSlotBySharedSlot(t, e) {
+    const s = t.toDelta(), n = t.getAttributes();
+    Object.keys(n).forEach((o) => {
+      const r = this.registry.getAttribute(o);
+      r && e.setAttribute(r, n[o]);
+    });
+    for (const o of s)
+      if (o.insert)
+        if (typeof o.insert == "string") {
+          const r = C(this.registry, o.attributes);
+          e.insert(o.insert, r);
+        } else {
+          const r = o.insert, a = this.createLocalComponentBySharedComponent(r);
+          e.insert(a, C(this.registry, o.attributes));
+        }
+      else
+        throw g("unexpected delta action.");
+  }
+  createSharedModelByLocalModel(t) {
+    return t instanceof m ? this.createSharedSlotByLocalSlot(t) : Array.isArray(t) ? this.createSharedArrayByLocalArray(t) : typeof t == "object" && t !== null ? this.createSharedMapByLocalMap(t) : t;
+  }
+  createLocalModelBySharedByModel(t) {
+    return t instanceof S ? this.createLocalMapBySharedMap(t) : t instanceof F ? this.createLocalArrayBySharedArray(t) : t instanceof v ? this.createLocalSlotBySharedSlot(t) : t;
+  }
+  createSharedComponentByLocalComponent(t) {
+    const e = new S();
+    if (e.set("name", t.name), t instanceof D) {
+      e.set("type", "async");
+      const n = this.createSharedMapByLocalMap(t.metadata);
+      e.set("metadata", n);
+      const o = t.state;
+      let r = !1;
+      return o.__changeMarker__.addDetachCallback(() => {
+        r = !0;
+      }), this.subModelLoader.createSubModelByComponent(t).then((a) => {
+        if (r)
+          return;
+        const i = a.getMap("state");
+        this.syncComponent(a, i, t), this.addSubModelEvent.next({
+          yType: i,
+          yDoc: a
+        }), this.initSyncEvent(a), t.loader.markAsLoaded();
+      }), e;
+    }
+    const s = this.createSharedMapByLocalMap(t.state);
+    return e.set("state", s), e.set("type", "sync"), e;
+  }
+  createLocalComponentBySharedComponent(t) {
+    const e = t.get("name"), s = t.get("type");
+    let n;
+    if (s === "async") {
+      if (n = this.registry.createComponentByData(e, {}, {}), n instanceof D) {
+        const o = t.get("metadata");
+        this.syncSharedMapToLocalMap(o, n.metadata);
+        const r = this.subModelLoader.getLoadedModelByComponent(n);
+        if (r) {
+          const c = r.getMap("state");
+          return this.syncComponent(r, c, n), this.addSubModelEvent.next({
+            yType: c,
+            yDoc: r
+          }), n.loader.markAsLoaded(), n;
+        }
+        const a = n.state;
+        let i = !1;
+        n.loader.onRequestLoad.toPromise().then(() => this.subModelLoader.loadSubModelByComponent(n)).then((c) => {
+          if (i)
+            return;
+          const h = c.getMap("state");
+          this.syncComponent(c, h, n), this.addSubModelEvent.next({
+            yType: h,
+            yDoc: c
+          }), n.loader.markAsLoaded();
+        }), a.__changeMarker__.addDetachCallback(() => {
+          i = !0;
+        });
+      } else if (n instanceof N)
+        throw g(`component name \`${e}\` is not a async component.`);
+    } else {
+      const o = t.get("state"), r = this.createLocalMapBySharedMap(o);
+      n = this.registry.createComponentByData(e, r);
+    }
+    if (n)
+      return n;
+    throw g(`cannot find component factory \`${e}\`.`);
+  }
+  /**
+   * 双向同步数组
+   * @param sharedArray
+   * @param localArray
+   * @private
+   */
+  syncArray(t, e) {
+    function s(r) {
+      console.error(g(`${r} error, length exceeded, path in ${e.__changeMarker__.getPaths().join("/")}`));
+    }
+    const n = e.__changeMarker__.onSelfChange.subscribe((r) => {
+      this.runLocalUpdate(t.doc, !e.__changeMarker__.irrevocableUpdate, () => {
+        let a = 0;
+        for (const i of r)
+          switch (i.type) {
+            case "retain":
+              a = i.offset;
+              break;
+            case "insert":
+              {
+                const c = i.ref;
+                if (!Array.isArray(c))
+                  throw g("The insertion action must have a reference value.");
+                const h = c.map((d) => this.createSharedModelByLocalModel(d));
+                a <= t.length ? t.insert(a, h) : (t.insert(t.length, h), s("insert"));
+              }
+              break;
+            case "delete":
+              if (i.count <= 0)
+                break;
+              a < t.length ? t.delete(a, i.count) : s("delete");
+              break;
+            case "setIndex":
+              i.index < t.length ? (t.delete(i.index, 1), t.insert(i.index, [this.createSharedModelByLocalModel(i.ref)])) : (t.insert(t.length, [this.createSharedModelByLocalModel(i.ref)]), s("setIndex"));
+              break;
+          }
+      });
+    }), o = (r, a) => {
+      this.runRemoteUpdate(a, () => {
+        let i = 0;
+        r.delta.forEach((c) => {
+          if (Reflect.has(c, "retain"))
+            i += c.retain;
+          else if (c.insert) {
+            const h = c.insert.map((d) => this.createLocalModelBySharedByModel(d));
+            e.splice(i, 0, ...h), i += h.length;
+          } else c.delete && e.splice(i, c.delete);
+        });
+      });
+    };
+    t.observe(o), e.__changeMarker__.addDetachCallback(() => {
+      n.unsubscribe(), t.unobserve(o);
+    });
+  }
+  /**
+   * 双向同步对象
+   * @param sharedObject
+   * @param localObject
+   * @private
+   */
+  syncObject(t, e) {
+    const s = (o, r) => {
+      this.runRemoteUpdate(r, () => {
+        o.changes.keys.forEach((a, i) => {
+          if (a.action === "add" || a.action === "update") {
+            const c = t.get(i);
+            e[i] = this.createLocalModelBySharedByModel(c);
+          } else
+            Reflect.deleteProperty(e, i);
+        });
+      });
+    };
+    t.observe(s);
+    const n = e.__changeMarker__.onSelfChange.subscribe((o) => {
+      this.runLocalUpdate(t.doc, !e.__changeMarker__.irrevocableUpdate, () => {
+        for (const r of o)
+          switch (r.type) {
+            case "propSet":
+              {
+                const a = this.createSharedModelByLocalModel(r.ref);
+                t.set(r.key, a), t.size === 0 && console.error(g(`prop set error, key is ${r.key}`));
+              }
+              break;
+            case "propDelete":
+              t.delete(r.key);
+              break;
+          }
+      });
+    });
+    e.__changeMarker__.addDetachCallback(function() {
+      t.unobserve(s), n.unsubscribe();
+    });
+  }
+  runLocalUpdate(t, e, s) {
+    if (this.updateFromRemote || !t)
+      return;
+    let n = this.updateRemoteActions.get(t);
+    n || (n = [], this.updateRemoteActions.set(t, n)), n.push({
+      record: e,
+      action: s
+    });
+  }
+  runRemoteUpdate(t, e) {
+    t.origin !== t.doc && (this.updateFromRemote = !0, t.origin instanceof b ? this.scheduler.historyApplyTransact(e) : this.scheduler.remoteUpdateTransact(e), this.updateFromRemote = !1);
+  }
+};
+f = se([
+  w()
+], f);
+function C(t, e) {
+  const s = [];
+  return e && Object.keys(e).forEach((n) => {
+    const o = t.getFormatter(n);
+    o && s.push([o, e[n]]);
+  }), s;
+}
+class z {
+  onSync;
+  syncEvent = new l();
+  constructor() {
+    this.onSync = this.syncEvent.asObservable();
+  }
+  /**
+   * 立即同步消息
+   */
+  sync() {
+    this.syncEvent.next();
+  }
+}
+var oe = Object.getOwnPropertyDescriptor, re = (t, e, s, n) => {
+  for (var o = n > 1 ? void 0 : n ? oe(e, s) : e, r = t.length - 1, a; r >= 0; r--)
+    (a = t[r]) && (o = a(o) || o);
+  return o;
+}, U = (t, e) => (s, n) => e(s, n, t);
+let k = class {
+  constructor(t, e, s, n, o) {
+    this.collaborate = t, this.scheduler = e, this.rootComponentRef = s, this.stackSize = n, this.undoManagerConfig = o, this.onChange = this.changeEvent.asObservable(), this.onBack = this.backEvent.asObservable(), this.onForward = this.forwardEvent.asObservable(), this.onPush = this.pushEvent.asObservable();
+  }
+  collaborate;
+  scheduler;
+  rootComponentRef;
+  stackSize;
+  undoManagerConfig;
+  onChange;
+  onBack;
+  onForward;
+  onPush;
+  get canBack() {
+    return this.actionStack.length > 0 && this.index > 0;
+  }
+  get canForward() {
+    return this.actionStack.length > 0 && this.index < this.actionStack.length;
+  }
+  isListen = !1;
+  changeEvent = new l();
+  backEvent = new l();
+  forwardEvent = new l();
+  pushEvent = new l();
+  actionStack = [];
+  index = 0;
+  stackItem = null;
+  timer = null;
+  beforePosition = null;
+  subscription = new _();
+  subDocs = /* @__PURE__ */ new Set();
+  listenerCaches = /* @__PURE__ */ new Set();
+  listen() {
+    this.isListen = !0;
+    const t = this.collaborate.yDoc.getMap("RootComponent"), e = this.rootComponentRef.component;
+    this.collaborate.syncRootComponent(this.collaborate.yDoc, t, e), this.listenItem(t, this.collaborate.yDoc), this.subscription.add(
+      this.collaborate.onAddSubModel.subscribe(({ yType: s, yDoc: n }) => {
+        this.subDocs.has(s) || (this.subDocs.add(s), this.isListen && this.listenItem(s, n));
+      }),
+      this.scheduler.onLocalChangeBefore.subscribe(() => {
+        this.beforePosition = this.collaborate.getRelativeCursorLocation();
+      })
+    );
+  }
+  forward() {
+    if (!this.canForward)
+      return;
+    clearTimeout(this.timer);
+    const t = this.actionStack[this.index];
+    if (t) {
+      for (const e of t.undoManagers)
+        e.redo();
+      this.collaborate.restoreCursorPosition(t.after);
+    }
+    this.index++, this.forwardEvent.next(), this.changeEvent.next();
+  }
+  back() {
+    if (!this.canBack)
+      return;
+    clearTimeout(this.timer);
+    let t;
+    this.stackItem ? (t = this.stackItem, this.stackItem = null) : (this.index--, t = this.actionStack[this.index]);
+    let e = t.undoManagers.length;
+    for (; e > 0; )
+      e--, t.undoManagers[e].undo();
+    if (t) {
+      const s = t.before;
+      this.collaborate.restoreCursorPosition(s), this.backEvent.next(), this.changeEvent.next();
+    }
+  }
+  clear() {
+    this.actionStack = [], this.stackItem = null, this.index = 0, this.beforePosition = null, clearTimeout(this.timer), this.listenerCaches.forEach((t) => {
+      t.clear();
+    }), this.changeEvent.next();
+  }
+  destroy() {
+    this.clear(), this.beforePosition = this.stackItem = null, this.subscription.unsubscribe(), this.listenerCaches.forEach((t) => {
+      t.destroy();
+    }), this.subDocs.clear(), this.listenerCaches.clear();
+  }
+  listenItem(t, e) {
+    const s = this.undoManagerConfig || {}, n = new b(t, {
+      trackedOrigins: /* @__PURE__ */ new Set([e]),
+      captureTimeout: 0,
+      captureTransaction(o) {
+        return s.captureTransaction ? s.captureTransaction(o) : !0;
+      },
+      deleteFilter(o) {
+        return s.deleteFilter ? s.deleteFilter(o) : !0;
+      }
+    });
+    n.on("stack-item-added", (o) => {
+      o.type === "undo" && !(o.origin instanceof b) && (this.index != this.actionStack.length && (this.actionStack.slice(this.index).forEach((a) => {
+        a.undoManagers.forEach((i) => {
+          i.clear(!1, !0);
+        });
+      }), this.actionStack.length = this.index, this.changeEvent.next()), this.stackItem === null && (this.stackItem = {
+        before: this.beforePosition,
+        after: null,
+        undoManagers: []
+      }, this.timer = setTimeout(() => {
+        this.actionStack.length >= this.stackSize ? this.actionStack.shift() : this.index++, this.stackItem.after = this.beforePosition, this.actionStack.push(this.stackItem), this.stackItem = null, this.pushEvent.next(), this.changeEvent.next();
+      }, 500)), this.stackItem.undoManagers.push(n));
+    }), this.listenerCaches.add(n);
+  }
+};
+k = re([
+  w(),
+  U(3, $(H)),
+  U(4, Y())
+], k);
+var ae = Object.getOwnPropertyDescriptor, ie = (t, e, s, n) => {
+  for (var o = n > 1 ? void 0 : n ? ae(e, s) : e, r = t.length - 1, a; r >= 0; r--)
+    (a = t[r]) && (o = a(o) || o);
+  return o;
+};
+const y = x("subModelLoaderError");
+class A {
+}
+let B = class extends A {
+  createSubModelBySlot() {
+    throw y("single document does not support async slot.");
+  }
+  createSubModelByComponent() {
+    throw y("single document does not support async component.");
+  }
+  loadSubModelByComponent() {
+    throw y("single document does not support async component.");
+  }
+  loadSubModelBySlot() {
+    throw y("single document does not support async slot.");
+  }
+  getLoadedModelBySlot() {
+    throw y("single document does not support async slot.");
+  }
+  getLoadedModelByComponent() {
+    throw y("single document does not support async component.");
+  }
+};
+B = ie([
+  w()
+], B);
+class p {
+  /**
+   * 当文档加载完成时触发的观察者
+   */
+  onLoad;
+  /**
+   * 当文档 awareness 状态变更时触发的观察者
+   */
+  onStateChange;
+  loadEvent = new l();
+  stateChangeEvent = new l();
+  constructor() {
+    this.onLoad = this.loadEvent.asObservable(), this.onStateChange = this.stateChangeEvent.asObservable();
+  }
+}
+class ge extends p {
+  provide;
+  constructor(e) {
+    super(), this.provide = new J({
+      ...e,
+      onSynced: (s) => {
+        e.onSynced?.(s), this.loadEvent.next();
+      },
+      onAwarenessUpdate: (s) => {
+        e.onAwarenessUpdate?.(s);
+        const n = s.states.map((o) => ({
+          clientId: o.clientId,
+          message: o.message
+        }));
+        this.stateChangeEvent.next(n);
+      }
+    });
+  }
+  setLocalStateField(e, s) {
+    this.provide.setAwarenessField(e, s);
+  }
+  onDestroy() {
+    this.provide.disconnect(), this.provide.destroy();
+  }
+}
+class ye extends p {
+  provide;
+  onSync = (e) => {
+    e && this.loadEvent.next();
+  };
+  onUpdate = () => {
+    const e = [];
+    this.provide.awareness.getStates().forEach((s, n) => {
+      e.push({
+        clientId: n,
+        message: s.message
+      });
+    }), this.stateChangeEvent.next(e);
+  };
+  constructor(e, s, n) {
+    super(), this.onLoad = this.loadEvent.asObservable(), this.onStateChange = this.stateChangeEvent.asObservable(), this.provide = new Q(e, s, n), this.provide.once("sync", this.onSync), this.provide.awareness.on("update", this.onUpdate);
+  }
+  setLocalStateField(e, s) {
+    this.provide.awareness.setLocalStateField(e, s);
+  }
+  onDestroy() {
+    this.provide.awareness.off("update", this.onUpdate), this.provide.disconnect(), this.provide.destroy();
+  }
+}
+class me {
+  constructor(e) {
+    this.config = e;
+  }
+  config;
+  subscription = new _();
+  providers = [
+    f,
+    E,
+    {
+      provide: L,
+      useExisting: E
+    },
+    {
+      provide: p,
+      useFactory: (e) => this.config.createConnector(e.yDoc),
+      deps: [f]
+    },
+    {
+      provide: A,
+      useClass: B
+    }
+  ];
+  timer = null;
+  setup(e) {
+    const s = e.get(z, null), n = e.get(p), o = e.get(f);
+    if (s) {
+      const r = e.get(j);
+      n.setLocalStateField("message", s.get(e)), this.subscription.add(
+        s.onSync.subscribe(() => {
+          n.setLocalStateField("message", s.get(e));
+        }),
+        r.onChange.subscribe(() => {
+          n.setLocalStateField("message", s.get(e));
+        }),
+        n.onStateChange.subscribe((a) => {
+          s.consume(a, e);
+        })
+      );
+    }
+    return n.onLoad.toPromise().then(() => {
+      if (!this.config.onlyLoad)
+        return;
+      const r = o.yDoc.getMap("RootComponent");
+      if (!r.has("state"))
+        return new Promise((a) => {
+          const i = () => {
+            r.has("state") ? a() : this.timer = setTimeout(i, 1e3);
+          };
+          this.timer = setTimeout(i, 1e3);
+        });
+    });
+  }
+  onDestroy(e) {
+    this.subscription.unsubscribe(), e.get(f).destroy(), e.get(L).destroy(), e.get(p).onDestroy(), clearTimeout(this.timer);
+  }
+}
+class be {
+  constructor(e) {
+    this.config = e;
+  }
+  config;
+  subscription = new _();
+  providers = [
+    f,
+    k,
+    {
+      provide: L,
+      useExisting: k
+    },
+    {
+      provide: p,
+      useFactory: (e) => this.config.createConnector(e.yDoc),
+      deps: [f]
+    },
+    {
+      provide: A,
+      useFactory: () => this.config.subModelLoader
+    }
+  ];
+  timer = null;
+  setup(e) {
+    const s = e.get(z, null), n = e.get(p), o = e.get(f);
+    if (s) {
+      const r = e.get(j);
+      n.setLocalStateField("message", s.get(e)), this.subscription.add(
+        s.onSync.subscribe(() => {
+          n.setLocalStateField("message", s.get(e));
+        }),
+        r.onChange.subscribe(() => {
+          n.setLocalStateField("message", s.get(e));
+        }),
+        n.onStateChange.subscribe((a) => {
+          s.consume(a, e);
+        })
+      );
+    }
+    return n.onLoad.toPromise().then(() => {
+      if (!this.config.onlyLoad)
+        return;
+      const r = o.yDoc.getMap("RootComponent");
+      if (!r.has("state"))
+        return new Promise((a) => {
+          const i = () => {
+            r.has("state") ? a() : this.timer = setTimeout(i, 1e3);
+          };
+          this.timer = setTimeout(i, 1e3);
+        });
+    });
+  }
+  onDestroy(e) {
+    this.subscription.unsubscribe(), e.get(f).destroy(), e.get(L).destroy(), e.get(p).onDestroy(), clearTimeout(this.timer);
+  }
+}
+export {
+  E as CollabHistory,
+  f as Collaborate,
+  me as CollaborateModule,
+  pe as CustomUndoManagerConfig,
+  ge as HocuspocusConnector,
+  z as MessageBus,
+  k as MultipleDocCollabHistory,
+  be as MultipleDocumentCollaborateModule,
+  B as NonSubModelLoader,
+  A as SubModelLoader,
+  p as SyncConnector,
+  ye as YWebsocketConnector
+};
+//# sourceMappingURL=index.esm.js.map