@univerjs/thread-comment 0.5.4 → 0.5.5-experimental.20250123-34738ff

package/lib/es/index.js

@@ -1,536 +1,540 @@
-var A = Object.defineProperty;
-var j = (s, t, e) => t in s ? A(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
-var u = (s, t, e) => j(s, typeof t != "symbol" ? t + "" : t, e);
-import { createIdentifier as L, Disposable as U, Inject as g, LifecycleService as V, LifecycleStages as O, IResourceManagerService as W, CommandType as l, ICommandService as C, Plugin as H, merge as J, UniverInstanceType as G, mergeOverrideWithDependencies as b, Injector as Y, IConfigService as K, dayjs as B } from "@univerjs/core";
-import { Subject as Z } from "rxjs";
-class F extends U {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { createIdentifier, Disposable, Inject, LifecycleService, LifecycleStages, IResourceManagerService, CommandType, ICommandService, Plugin, merge, UniverInstanceType, mergeOverrideWithDependencies, Injector, IConfigService, dayjs } from "@univerjs/core";
+import { Subject } from "rxjs";
+const _ThreadCommentDataSourceService = class _ThreadCommentDataSourceService extends Disposable {
   constructor() {
     super();
-    u(this, "_dataSource", null);
-    u(this, "syncUpdateMutationToColla", !0);
+    __publicField(this, "_dataSource", null);
+    __publicField(this, "syncUpdateMutationToColla", !0);
   }
-  set dataSource(e) {
-    this._dataSource = e;
+  set dataSource(dataSource) {
+    this._dataSource = dataSource;
   }
   get dataSource() {
     return this._dataSource;
   }
-  async getThreadComment(e, n, o) {
-    return this._dataSource ? (await this._dataSource.listComments(e, n, [o]))[0] : null;
+  async getThreadComment(unitId, subUnitId, threadId) {
+    return this._dataSource ? (await this._dataSource.listComments(unitId, subUnitId, [threadId]))[0] : null;
   }
-  async addComment(e) {
-    var n;
-    return this._dataSource ? this._dataSource.addComment(e) : { ...e, threadId: (n = e.threadId) != null ? n : e.id };
+  async addComment(comment) {
+    var _a4;
+    return this._dataSource ? this._dataSource.addComment(comment) : { ...comment, threadId: (_a4 = comment.threadId) != null ? _a4 : comment.id };
   }
-  async updateComment(e) {
-    return this._dataSource ? this._dataSource.updateComment(e) : !0;
+  async updateComment(comment) {
+    return this._dataSource ? this._dataSource.updateComment(comment) : !0;
   }
-  async resolveComment(e) {
-    return this._dataSource ? this._dataSource.resolveComment(e) : !0;
+  async resolveComment(comment) {
+    return this._dataSource ? this._dataSource.resolveComment(comment) : !0;
   }
-  async deleteComment(e, n, o, r) {
-    return this._dataSource ? this._dataSource.deleteComment(e, n, o, r) : !0;
+  async deleteComment(unitId, subUnitId, threadId, commentId) {
+    return this._dataSource ? this._dataSource.deleteComment(unitId, subUnitId, threadId, commentId) : !0;
   }
-  async listThreadComments(e, n, o) {
-    return this.dataSource ? this.dataSource.listComments(e, n, o) : !1;
+  async listThreadComments(unitId, subUnitId, threadIds) {
+    return this.dataSource ? this.dataSource.listComments(unitId, subUnitId, threadIds) : !1;
   }
-  saveToSnapshot(e, n) {
+  saveToSnapshot(unitComments, unitId) {
     if (this._dataSource) {
-      const o = {};
-      return Object.keys(e).forEach((r) => {
-        const a = e[r];
-        o[r] = a.map(this.dataSource.saveCommentToSnapshot);
-      }), o;
+      const map = {};
+      return Object.keys(unitComments).forEach((subUnitId) => {
+        const comments = unitComments[subUnitId];
+        map[subUnitId] = comments.map(this.dataSource.saveCommentToSnapshot);
+      }), map;
     }
-    return e;
+    return unitComments;
   }
-}
-const p = L("univer.thread-comment.data-source-service");
-var q = Object.defineProperty, z = Object.getOwnPropertyDescriptor, Q = (s, t, e, n) => {
-  for (var o = n > 1 ? void 0 : n ? z(t, e) : t, r = s.length - 1, a; r >= 0; r--)
-    (a = s[r]) && (o = (n ? a(t, e, o) : a(o)) || o);
-  return n && o && q(t, e, o), o;
-}, I = (s, t) => (e, n) => t(e, n, s);
-let i = class extends U {
-  constructor(t, e) {
+};
+__name(_ThreadCommentDataSourceService, "ThreadCommentDataSourceService");
+let ThreadCommentDataSourceService = _ThreadCommentDataSourceService;
+const IThreadCommentDataSourceService = createIdentifier("univer.thread-comment.data-source-service");
+var __defProp$2 = Object.defineProperty, __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor, __decorateClass$2 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$2(target, key, result), result;
+}, "__decorateClass$2"), __decorateParam$2 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$2"), _a;
+let ThreadCommentModel = (_a = class extends Disposable {
+  constructor(_dataSourceService, _lifecycleService) {
     super();
-    u(this, "_commentsMap", /* @__PURE__ */ new Map());
-    u(this, "_threadMap", /* @__PURE__ */ new Map());
-    u(this, "_commentUpdate$", new Z());
-    u(this, "commentUpdate$", this._commentUpdate$.asObservable());
-    u(this, "_tasks", []);
-    this._dataSourceService = t, this._lifecycleService = e, this.disposeWithMe(() => {
+    __publicField(this, "_commentsMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_threadMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_commentUpdate$", new Subject());
+    __publicField(this, "commentUpdate$", this._commentUpdate$.asObservable());
+    __publicField(this, "_tasks", []);
+    this._dataSourceService = _dataSourceService, this._lifecycleService = _lifecycleService, this.disposeWithMe(() => {
       this._commentUpdate$.complete();
-    }), this.disposeWithMe(this._lifecycleService.lifecycle$.subscribe((n) => {
-      const o = /* @__PURE__ */ new Map();
-      n === O.Rendered && (this._tasks.forEach(({ unitId: r, subUnitId: a, threadIds: d }) => {
-        let m = o.get(r);
-        m || (m = /* @__PURE__ */ new Map(), o.set(r, m));
-        let c = m.get(a);
-        c || (c = /* @__PURE__ */ new Set(), m.set(a, c));
-        for (const h of d)
-          c.add(h);
-      }), this._tasks = [], o.forEach((r, a) => {
-        r.forEach((d, m) => {
-          this.syncThreadComments(a, m, Array.from(d));
+    }), this.disposeWithMe(this._lifecycleService.lifecycle$.subscribe((stage) => {
+      const taskMap = /* @__PURE__ */ new Map();
+      stage === LifecycleStages.Rendered && (this._tasks.forEach(({ unitId, subUnitId, threadIds }) => {
+        let unitMap = taskMap.get(unitId);
+        unitMap || (unitMap = /* @__PURE__ */ new Map(), taskMap.set(unitId, unitMap));
+        let subUnitMap = unitMap.get(subUnitId);
+        subUnitMap || (subUnitMap = /* @__PURE__ */ new Set(), unitMap.set(subUnitId, subUnitMap));
+        for (const threadId of threadIds)
+          subUnitMap.add(threadId);
+      }), this._tasks = [], taskMap.forEach((subUnitMap, unitId) => {
+        subUnitMap.forEach((threadIds, subUnitId) => {
+          this.syncThreadComments(unitId, subUnitId, Array.from(threadIds));
         });
       }));
     }));
   }
-  _ensureCommentMap(t, e) {
-    let n = this._commentsMap.get(t);
-    n || (n = /* @__PURE__ */ new Map(), this._commentsMap.set(t, n));
-    let o = n.get(e);
-    return o || (o = /* @__PURE__ */ new Map(), n.set(e, o)), o;
-  }
-  ensureMap(t, e) {
-    return this._ensureCommentMap(t, e);
-  }
-  _ensureThreadMap(t, e) {
-    let n = this._threadMap.get(t);
-    n || (n = /* @__PURE__ */ new Map(), this._threadMap.set(t, n));
-    let o = n.get(e);
-    return o || (o = /* @__PURE__ */ new Map(), n.set(e, o)), o;
-  }
-  _replaceComment(t, e, n) {
-    const o = this._ensureCommentMap(t, e), r = o.get(n.id);
-    if (r) {
-      const { children: a, ...d } = n, m = {
-        ...d,
-        ref: r.ref
+  _ensureCommentMap(unitId, subUnitId) {
+    let unitMap = this._commentsMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._commentsMap.set(unitId, unitMap));
+    let subUnitMap = unitMap.get(subUnitId);
+    return subUnitMap || (subUnitMap = /* @__PURE__ */ new Map(), unitMap.set(subUnitId, subUnitMap)), subUnitMap;
+  }
+  ensureMap(unitId, subUnitId) {
+    return this._ensureCommentMap(unitId, subUnitId);
+  }
+  _ensureThreadMap(unitId, subUnitId) {
+    let unitMap = this._threadMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._threadMap.set(unitId, unitMap));
+    let subUnitMap = unitMap.get(subUnitId);
+    return subUnitMap || (subUnitMap = /* @__PURE__ */ new Map(), unitMap.set(subUnitId, subUnitMap)), subUnitMap;
+  }
+  _replaceComment(unitId, subUnitId, comment) {
+    const commentMap = this._ensureCommentMap(unitId, subUnitId), currentComment = commentMap.get(comment.id);
+    if (currentComment) {
+      const { children, ...rest } = comment, newComment = {
+        ...rest,
+        ref: currentComment.ref
       };
-      o.set(n.id, m), a == null || a.forEach((c) => {
-        o.set(c.id, {
-          ...c,
+      commentMap.set(comment.id, newComment), children == null || children.forEach((child) => {
+        commentMap.set(child.id, {
+          ...child,
           ref: ""
         });
       }), this._commentUpdate$.next({
-        unitId: t,
-        subUnitId: e,
+        unitId,
+        subUnitId,
         type: "syncUpdate",
-        payload: m
-      }), !!n.resolved != !!r.resolved && this._commentUpdate$.next({
-        unitId: t,
-        subUnitId: e,
+        payload: newComment
+      }), !!comment.resolved != !!currentComment.resolved && this._commentUpdate$.next({
+        unitId,
+        subUnitId,
         type: "resolve",
         payload: {
-          commentId: n.id,
-          resolved: !!n.resolved
+          commentId: comment.id,
+          resolved: !!comment.resolved
         }
       });
     }
   }
-  async syncThreadComments(t, e, n) {
-    if (this._lifecycleService.stage < O.Rendered) {
-      this._tasks.push({ unitId: t, subUnitId: e, threadIds: n });
+  async syncThreadComments(unitId, subUnitId, threadIds) {
+    if (this._lifecycleService.stage < LifecycleStages.Rendered) {
+      this._tasks.push({ unitId, subUnitId, threadIds });
       return;
     }
-    const o = this._ensureThreadMap(t, e), r = this._ensureCommentMap(t, e), a = await this._dataSourceService.listThreadComments(t, e, n);
-    if (!a)
+    const threadMap = this._ensureThreadMap(unitId, subUnitId), commentMap = this._ensureCommentMap(unitId, subUnitId), comments = await this._dataSourceService.listThreadComments(unitId, subUnitId, threadIds);
+    if (!comments)
       return;
-    const d = new Set(n);
-    a.forEach((m) => {
-      this._replaceComment(t, e, m), d.delete(m.threadId);
-    }), d.forEach((m) => {
-      o.delete(m), r.forEach((c, h) => {
-        c.threadId === m && r.delete(h);
+    const deleteThreads = new Set(threadIds);
+    comments.forEach((comment) => {
+      this._replaceComment(unitId, subUnitId, comment), deleteThreads.delete(comment.threadId);
+    }), deleteThreads.forEach((id) => {
+      threadMap.delete(id), commentMap.forEach((comment, commentId) => {
+        comment.threadId === id && commentMap.delete(commentId);
       });
     });
   }
-  addComment(t, e, n, o) {
-    const r = this._ensureCommentMap(t, e), { parentId: a, children: d = [], ...m } = n, c = {
-      ...m,
-      parentId: a === n.id ? void 0 : a
+  addComment(unitId, subUnitId, origin, shouldSync) {
+    const commentMap = this._ensureCommentMap(unitId, subUnitId), { parentId, children = [], ...rest } = origin, comment = {
+      ...rest,
+      parentId: parentId === origin.id ? void 0 : parentId
     };
-    c.threadId || (c.threadId = c.parentId || c.id);
-    const h = (f) => {
-      r.set(f.id, f), this._commentUpdate$.next({
-        unitId: t,
-        subUnitId: e,
+    comment.threadId || (comment.threadId = comment.parentId || comment.id);
+    const addCommentItem = /* @__PURE__ */ __name((item) => {
+      commentMap.set(item.id, item), this._commentUpdate$.next({
+        unitId,
+        subUnitId,
         type: "add",
-        payload: f,
-        isRoot: !f.parentId
+        payload: item,
+        isRoot: !item.parentId
       });
-    };
-    h(c);
-    const _ = this._ensureThreadMap(t, e);
-    if (!c.parentId) {
-      _.set(c.threadId, c);
-      for (const f of d)
-        h(f);
+    }, "addCommentItem");
+    addCommentItem(comment);
+    const threadMap = this._ensureThreadMap(unitId, subUnitId);
+    if (!comment.parentId) {
+      threadMap.set(comment.threadId, comment);
+      for (const child of children)
+        addCommentItem(child);
     }
-    return o && this.syncThreadComments(t, e, [c.threadId]), !0;
+    return shouldSync && this.syncThreadComments(unitId, subUnitId, [comment.threadId]), !0;
   }
-  updateComment(t, e, n, o) {
-    const a = this._ensureCommentMap(t, e).get(n.commentId);
-    return a && (a.updated = !0, a.text = n.text, a.attachments = n.attachments, a.updateT = n.updateT, this._commentUpdate$.next({
-      unitId: t,
-      subUnitId: e,
+  updateComment(unitId, subUnitId, payload, silent) {
+    const oldComment = this._ensureCommentMap(unitId, subUnitId).get(payload.commentId);
+    return oldComment && (oldComment.updated = !0, oldComment.text = payload.text, oldComment.attachments = payload.attachments, oldComment.updateT = payload.updateT, this._commentUpdate$.next({
+      unitId,
+      subUnitId,
       type: "update",
-      payload: n,
-      silent: o
+      payload,
+      silent
     })), !0;
   }
-  updateCommentRef(t, e, n, o) {
-    const a = this._ensureCommentMap(t, e).get(n.commentId);
-    return a ? (a.ref = n.ref, this._commentUpdate$.next({
-      unitId: t,
-      subUnitId: e,
+  updateCommentRef(unitId, subUnitId, payload, silent) {
+    const oldComment = this._ensureCommentMap(unitId, subUnitId).get(payload.commentId);
+    return oldComment ? (oldComment.ref = payload.ref, this._commentUpdate$.next({
+      unitId,
+      subUnitId,
       type: "updateRef",
-      payload: n,
-      silent: o,
-      threadId: a.threadId
+      payload,
+      silent,
+      threadId: oldComment.threadId
     }), !0) : !1;
   }
-  resolveComment(t, e, n, o) {
-    const a = this._ensureCommentMap(t, e).get(n);
-    return a ? (a.resolved = o, this._commentUpdate$.next({
-      unitId: t,
-      subUnitId: e,
+  resolveComment(unitId, subUnitId, commentId, resolved) {
+    const oldComment = this._ensureCommentMap(unitId, subUnitId).get(commentId);
+    return oldComment ? (oldComment.resolved = resolved, this._commentUpdate$.next({
+      unitId,
+      subUnitId,
       type: "resolve",
       payload: {
-        commentId: n,
-        resolved: o
+        commentId,
+        resolved
       }
     }), !0) : !1;
   }
-  getComment(t, e, n) {
-    return this._ensureCommentMap(t, e).get(n);
+  getComment(unitId, subUnitId, commentId) {
+    return this._ensureCommentMap(unitId, subUnitId).get(commentId);
   }
-  getRootComment(t, e, n) {
-    return this._ensureThreadMap(t, e).get(n);
+  getRootComment(unitId, subUnitId, threadId) {
+    return this._ensureThreadMap(unitId, subUnitId).get(threadId);
   }
-  getThread(t, e, n) {
-    const o = this._ensureCommentMap(t, e), r = Array.from(o.values()).filter((c) => c.threadId === n);
-    let a;
-    const d = [], m = /* @__PURE__ */ new Set();
-    for (const c of r)
-      c.parentId ? d.push(c) : a = c, m.add(c.personId);
-    if (a)
+  getThread(unitId, subUnitId, threadId) {
+    const commentMap = this._ensureCommentMap(unitId, subUnitId), comments = Array.from(commentMap.values()).filter((comment) => comment.threadId === threadId);
+    let root;
+    const children = [], relativeUsers = /* @__PURE__ */ new Set();
+    for (const comment of comments)
+      comment.parentId ? children.push(comment) : root = comment, relativeUsers.add(comment.personId);
+    if (root)
       return {
-        root: a,
-        children: d,
-        relativeUsers: m,
-        unitId: t,
-        subUnitId: e,
-        threadId: n
+        root,
+        children,
+        relativeUsers,
+        unitId,
+        subUnitId,
+        threadId
       };
   }
-  getCommentWithChildren(t, e, n) {
-    const o = this.getComment(t, e, n);
-    if (o)
-      return this.getThread(t, e, o.threadId);
+  getCommentWithChildren(unitId, subUnitId, commentId) {
+    const comment = this.getComment(unitId, subUnitId, commentId);
+    if (comment)
+      return this.getThread(unitId, subUnitId, comment.threadId);
   }
-  _deleteComment(t, e, n) {
-    const o = this._ensureCommentMap(t, e), r = o.get(n);
-    r && (o.delete(n), this._commentUpdate$.next({
-      unitId: t,
-      subUnitId: e,
+  _deleteComment(unitId, subUnitId, commentId) {
+    const commentMap = this._ensureCommentMap(unitId, subUnitId), current = commentMap.get(commentId);
+    current && (commentMap.delete(commentId), this._commentUpdate$.next({
+      unitId,
+      subUnitId,
       type: "delete",
       payload: {
-        commentId: n,
-        isRoot: !r.parentId,
-        comment: r
+        commentId,
+        isRoot: !current.parentId,
+        comment: current
       }
     }));
   }
-  deleteThread(t, e, n) {
-    this._ensureThreadMap(t, e).delete(n), this._ensureCommentMap(t, e).forEach((a) => {
-      a.threadId === n && this._deleteComment(t, e, a.id);
+  deleteThread(unitId, subUnitId, threadId) {
+    this._ensureThreadMap(unitId, subUnitId).delete(threadId), this._ensureCommentMap(unitId, subUnitId).forEach((comment) => {
+      comment.threadId === threadId && this._deleteComment(unitId, subUnitId, comment.id);
     });
   }
-  deleteComment(t, e, n) {
-    const r = this._ensureCommentMap(t, e).get(n);
-    return r && (r.parentId ? this._deleteComment(t, e, n) : this.deleteThread(t, e, r.threadId)), !0;
+  deleteComment(unitId, subUnitId, commentId) {
+    const current = this._ensureCommentMap(unitId, subUnitId).get(commentId);
+    return current && (current.parentId ? this._deleteComment(unitId, subUnitId, commentId) : this.deleteThread(unitId, subUnitId, current.threadId)), !0;
   }
-  deleteUnit(t) {
-    const e = this._commentsMap.get(t);
-    e && e.forEach((n, o) => {
-      n.forEach((r) => {
-        this.deleteComment(t, o, r.id);
+  deleteUnit(unitId) {
+    const unitMap = this._commentsMap.get(unitId);
+    unitMap && unitMap.forEach((subUnitMap, subUnitId) => {
+      subUnitMap.forEach((comment) => {
+        this.deleteComment(unitId, subUnitId, comment.id);
       });
     });
   }
-  getUnit(t) {
-    const e = this._threadMap.get(t);
-    if (!e)
+  getUnit(unitId) {
+    const unitMap = this._threadMap.get(unitId);
+    if (!unitMap)
       return [];
-    const n = [];
-    return e.forEach((o, r) => {
-      o.forEach((a, d) => {
-        const m = this.getThread(t, r, d);
-        m && n.push(m);
+    const threads = [];
+    return unitMap.forEach((subUnitSet, subUnitId) => {
+      subUnitSet.forEach((threadComment, threadId) => {
+        const thread = this.getThread(unitId, subUnitId, threadId);
+        thread && threads.push(thread);
       });
-    }), n;
+    }), threads;
   }
   getAll() {
-    const t = [];
-    return this._commentsMap.forEach((e, n) => {
-      t.push({
-        unitId: n,
-        threads: this.getUnit(n)
+    const all = [];
+    return this._commentsMap.forEach((unitMap, unitId) => {
+      all.push({
+        unitId,
+        threads: this.getUnit(unitId)
       });
-    }), t;
-  }
-};
-i = Q([
-  I(0, g(p)),
-  I(1, g(V))
-], i);
-var T = /* @__PURE__ */ ((s) => (s[s.UNIVER_UNKNOWN = 0] = "UNIVER_UNKNOWN", s[s.UNIVER_DOC = 1] = "UNIVER_DOC", s[s.UNIVER_SHEET = 2] = "UNIVER_SHEET", s[s.UNIVER_SLIDE = 3] = "UNIVER_SLIDE", s[s.UNIVER_PROJECT = 4] = "UNIVER_PROJECT", s[s.UNRECOGNIZED = -1] = "UNRECOGNIZED", s))(T || {});
-const w = "UNIVER_THREAD_COMMENT_PLUGIN";
-var X = Object.defineProperty, k = Object.getOwnPropertyDescriptor, ee = (s, t, e, n) => {
-  for (var o = n > 1 ? void 0 : n ? k(t, e) : t, r = s.length - 1, a; r >= 0; r--)
-    (a = s[r]) && (o = (n ? a(t, e, o) : a(o)) || o);
-  return n && o && X(t, e, o), o;
-}, v = (s, t) => (e, n) => t(e, n, s);
-let S = class extends U {
-  constructor(s, t, e) {
-    super(), this._resourceManagerService = s, this._threadCommentModel = t, this._threadCommentDataSourceService = e, this._initSnapshot();
+    }), all;
+  }
+}, __name(_a, "ThreadCommentModel"), _a);
+ThreadCommentModel = __decorateClass$2([
+  __decorateParam$2(0, Inject(IThreadCommentDataSourceService)),
+  __decorateParam$2(1, Inject(LifecycleService))
+], ThreadCommentModel);
+var _ = /* @__PURE__ */ ((E) => (E[E.UNIVER_UNKNOWN = 0] = "UNIVER_UNKNOWN", E[E.UNIVER_DOC = 1] = "UNIVER_DOC", E[E.UNIVER_SHEET = 2] = "UNIVER_SHEET", E[E.UNIVER_SLIDE = 3] = "UNIVER_SLIDE", E[E.UNIVER_PROJECT = 4] = "UNIVER_PROJECT", E[E.UNRECOGNIZED = -1] = "UNRECOGNIZED", E))(_ || {});
+const TC_PLUGIN_NAME = "UNIVER_THREAD_COMMENT_PLUGIN";
+var __defProp$1 = Object.defineProperty, __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor, __decorateClass$1 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$1(target, key, result), result;
+}, "__decorateClass$1"), __decorateParam$1 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$1"), _a2;
+let ThreadCommentResourceController = (_a2 = class extends Disposable {
+  constructor(_resourceManagerService, _threadCommentModel, _threadCommentDataSourceService) {
+    super(), this._resourceManagerService = _resourceManagerService, this._threadCommentModel = _threadCommentModel, this._threadCommentDataSourceService = _threadCommentDataSourceService, this._initSnapshot();
   }
   _initSnapshot() {
-    const s = (e) => {
-      const n = this._threadCommentModel.getUnit(e), o = {};
-      return n ? (n.forEach((r) => {
-        var d;
-        const a = (d = o[r.subUnitId]) != null ? d : [];
-        a.push({
-          ...r.root,
-          children: r.children
-        }), o[r.subUnitId] = a;
-      }), JSON.stringify(this._threadCommentDataSourceService.saveToSnapshot(o, e))) : "";
-    }, t = (e) => {
-      if (!e)
+    const toJson = /* @__PURE__ */ __name((unitID) => {
+      const map = this._threadCommentModel.getUnit(unitID), resultMap = {};
+      return map ? (map.forEach((info) => {
+        var _a4;
+        const subUnitComments = (_a4 = resultMap[info.subUnitId]) != null ? _a4 : [];
+        subUnitComments.push({
+          ...info.root,
+          children: info.children
+        }), resultMap[info.subUnitId] = subUnitComments;
+      }), JSON.stringify(this._threadCommentDataSourceService.saveToSnapshot(resultMap, unitID))) : "";
+    }, "toJson"), parseJson = /* @__PURE__ */ __name((json) => {
+      if (!json)
         return {};
       try {
-        return JSON.parse(e);
+        return JSON.parse(json);
       } catch {
         return {};
       }
-    };
+    }, "parseJson");
     this.disposeWithMe(
       this._resourceManagerService.registerPluginResource({
-        pluginName: `SHEET_${w}`,
-        businesses: [T.UNIVER_SHEET, T.UNIVER_DOC],
-        toJson: (e) => s(e),
-        parseJson: (e) => t(e),
-        onUnLoad: (e) => {
-          this._threadCommentModel.deleteUnit(e);
-        },
-        onLoad: async (e, n) => {
-          Object.keys(n).forEach((o) => {
-            const r = n[o];
-            r.forEach((a) => {
-              this._threadCommentModel.addComment(e, o, a);
-            }), this._threadCommentModel.syncThreadComments(e, o, r.map((a) => a.threadId));
+        pluginName: `SHEET_${TC_PLUGIN_NAME}`,
+        businesses: [_.UNIVER_SHEET, _.UNIVER_DOC],
+        toJson: /* @__PURE__ */ __name((unitID) => toJson(unitID), "toJson"),
+        parseJson: /* @__PURE__ */ __name((json) => parseJson(json), "parseJson"),
+        onUnLoad: /* @__PURE__ */ __name((unitID) => {
+          this._threadCommentModel.deleteUnit(unitID);
+        }, "onUnLoad"),
+        onLoad: /* @__PURE__ */ __name(async (unitID, value) => {
+          Object.keys(value).forEach((subunitId) => {
+            const commentList = value[subunitId];
+            commentList.forEach((comment) => {
+              this._threadCommentModel.addComment(unitID, subunitId, comment);
+            }), this._threadCommentModel.syncThreadComments(unitID, subunitId, commentList.map((i) => i.threadId));
           });
-        }
+        }, "onLoad")
       })
     );
   }
-};
-S = ee([
-  v(0, W),
-  v(1, g(i)),
-  v(2, p)
-], S);
-const P = {
+}, __name(_a2, "ThreadCommentResourceController"), _a2);
+ThreadCommentResourceController = __decorateClass$1([
+  __decorateParam$1(0, IResourceManagerService),
+  __decorateParam$1(1, Inject(ThreadCommentModel)),
+  __decorateParam$1(2, IThreadCommentDataSourceService)
+], ThreadCommentResourceController);
+const AddCommentMutation = {
   id: "thread-comment.mutation.add-comment",
-  type: l.MUTATION,
-  handler(s, t, e) {
-    if (!t)
+  type: CommandType.MUTATION,
+  handler(accessor, params, options) {
+    if (!params)
       return !1;
-    const n = s.get(i), { unitId: o, subUnitId: r, comment: a, sync: d } = t, m = d || (e == null ? void 0 : e.fromChangeset) && !a.parentId;
-    return n.addComment(o, r, a, m);
+    const threadCommentModel = accessor.get(ThreadCommentModel), { unitId, subUnitId, comment, sync } = params, shouldSync = sync || (options == null ? void 0 : options.fromChangeset) && !comment.parentId;
+    return threadCommentModel.addComment(unitId, subUnitId, comment, shouldSync);
   }
-}, $ = {
+}, UpdateCommentMutation = {
   id: "thread-comment.mutation.update-comment",
-  type: l.MUTATION,
-  handler(s, t) {
-    if (!t)
+  type: CommandType.MUTATION,
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), { unitId: n, subUnitId: o, payload: r, silent: a } = t;
-    return e.updateComment(n, o, r, a);
+    const threadCommentModel = accessor.get(ThreadCommentModel), { unitId, subUnitId, payload, silent } = params;
+    return threadCommentModel.updateComment(unitId, subUnitId, payload, silent);
   }
-}, te = {
+}, UpdateCommentRefMutation = {
   id: "thread-comment.mutation.update-comment-ref",
-  type: l.MUTATION,
-  handler(s, t) {
-    if (!t)
+  type: CommandType.MUTATION,
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), { unitId: n, subUnitId: o, payload: r, silent: a } = t;
-    return e.updateCommentRef(n, o, r, a);
+    const threadCommentModel = accessor.get(ThreadCommentModel), { unitId, subUnitId, payload, silent } = params;
+    return threadCommentModel.updateCommentRef(unitId, subUnitId, payload, silent);
   }
-}, x = {
+}, ResolveCommentMutation = {
   id: "thread-comment.mutation.resolve-comment",
-  type: l.MUTATION,
-  handler(s, t) {
-    if (!t)
+  type: CommandType.MUTATION,
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), { unitId: n, subUnitId: o, resolved: r, commentId: a } = t;
-    return e.resolveComment(n, o, a, r);
+    const threadCommentModel = accessor.get(ThreadCommentModel), { unitId, subUnitId, resolved, commentId } = params;
+    return threadCommentModel.resolveComment(unitId, subUnitId, commentId, resolved);
   }
-}, N = {
+}, DeleteCommentMutation = {
   id: "thread-comment.mutation.delete-comment",
-  type: l.MUTATION,
-  handler(s, t) {
-    if (!t)
+  type: CommandType.MUTATION,
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), { unitId: n, subUnitId: o, commentId: r } = t;
-    return e.deleteComment(n, o, r);
+    const threadCommentModel = accessor.get(ThreadCommentModel), { unitId, subUnitId, commentId } = params;
+    return threadCommentModel.deleteComment(unitId, subUnitId, commentId);
   }
-}, ne = {
+}, AddCommentCommand = {
   id: "thread-comment.command.add-comment",
-  type: l.COMMAND,
-  async handler(s, t) {
-    if (!t)
+  type: CommandType.COMMAND,
+  async handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(C), n = s.get(p), { comment: o } = t, r = await n.addComment(o), a = n.syncUpdateMutationToColla, d = !o.parentId, m = {
-      id: P.id,
+    const commandService = accessor.get(ICommandService), dataSourceService = accessor.get(IThreadCommentDataSourceService), { comment: originComment } = params, comment = await dataSourceService.addComment(originComment), syncUpdateMutationToColla = dataSourceService.syncUpdateMutationToColla, isRoot = !originComment.parentId, redo = {
+      id: AddCommentMutation.id,
       params: {
-        ...t,
-        comment: r
+        ...params,
+        comment
       }
     };
-    return d ? await e.executeCommand(m.id, m.params) : e.executeCommand(m.id, m.params, {
-      onlyLocal: !a
+    return isRoot ? await commandService.executeCommand(redo.id, redo.params) : commandService.executeCommand(redo.id, redo.params, {
+      onlyLocal: !syncUpdateMutationToColla
     });
   }
-}, oe = {
+}, UpdateCommentCommand = {
   id: "thread-comment.command.update-comment",
-  type: l.COMMAND,
-  async handler(s, t) {
-    if (!t)
+  type: CommandType.COMMAND,
+  async handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: e, subUnitId: n, payload: o } = t, r = s.get(C), a = s.get(i), d = s.get(p), m = d.syncUpdateMutationToColla, c = a.getComment(
-      e,
-      n,
-      o.commentId
+    const { unitId, subUnitId, payload } = params, commandService = accessor.get(ICommandService), threadCommentModel = accessor.get(ThreadCommentModel), dataSourceService = accessor.get(IThreadCommentDataSourceService), syncUpdateMutationToColla = dataSourceService.syncUpdateMutationToColla, current = threadCommentModel.getComment(
+      unitId,
+      subUnitId,
+      payload.commentId
     );
-    if (!c)
+    if (!current)
       return !1;
-    const { children: h, ..._ } = c;
-    if (!await d.updateComment({
-      ..._,
-      ...o
+    const { children, ...currentComment } = current;
+    if (!await dataSourceService.updateComment({
+      ...currentComment,
+      ...payload
     }))
       return !1;
-    const E = {
-      id: $.id,
-      params: t
+    const redo = {
+      id: UpdateCommentMutation.id,
+      params
     };
-    return r.executeCommand(E.id, E.params, { onlyLocal: !m }), !0;
+    return commandService.executeCommand(redo.id, redo.params, { onlyLocal: !syncUpdateMutationToColla }), !0;
   }
-}, re = {
+}, ResolveCommentCommand = {
   id: "thread-comment.command.resolve-comment",
-  type: l.COMMAND,
-  async handler(s, t) {
-    if (!t)
+  type: CommandType.COMMAND,
+  async handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: e, subUnitId: n, resolved: o, commentId: r } = t, a = s.get(p), m = s.get(i).getComment(e, n, r), c = a.syncUpdateMutationToColla;
-    return !m || !await a.resolveComment({
-      ...m,
-      resolved: o
-    }) ? !1 : s.get(C).executeCommand(
-      x.id,
-      t,
-      { onlyLocal: !c }
+    const { unitId, subUnitId, resolved, commentId } = params, dataSourceService = accessor.get(IThreadCommentDataSourceService), currentComment = accessor.get(ThreadCommentModel).getComment(unitId, subUnitId, commentId), syncUpdateMutationToColla = dataSourceService.syncUpdateMutationToColla;
+    return !currentComment || !await dataSourceService.resolveComment({
+      ...currentComment,
+      resolved
+    }) ? !1 : accessor.get(ICommandService).executeCommand(
+      ResolveCommentMutation.id,
+      params,
+      { onlyLocal: !syncUpdateMutationToColla }
     );
   }
-}, ae = {
+}, DeleteCommentCommand = {
   id: "thread-comment.command.delete-comment",
-  type: l.COMMAND,
-  async handler(s, t) {
-    if (!t)
+  type: CommandType.COMMAND,
+  async handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), n = s.get(p), o = s.get(C), { unitId: r, subUnitId: a, commentId: d } = t, m = n.syncUpdateMutationToColla, c = e.getComment(r, a, d);
-    if (!c || !await n.deleteComment(r, a, c.threadId, d))
+    const threadCommentModel = accessor.get(ThreadCommentModel), dataSourceService = accessor.get(IThreadCommentDataSourceService), commandService = accessor.get(ICommandService), { unitId, subUnitId, commentId } = params, syncUpdateMutationToColla = dataSourceService.syncUpdateMutationToColla, comment = threadCommentModel.getComment(unitId, subUnitId, commentId);
+    if (!comment || !await dataSourceService.deleteComment(unitId, subUnitId, comment.threadId, commentId))
       return !1;
-    const h = {
-      id: N.id,
-      params: t
+    const redo = {
+      id: DeleteCommentMutation.id,
+      params
     };
-    return o.executeCommand(h.id, h.params, { onlyLocal: !m });
+    return commandService.executeCommand(redo.id, redo.params, { onlyLocal: !syncUpdateMutationToColla });
   }
-}, se = {
+}, DeleteCommentTreeCommand = {
   id: "thread-comment.command.delete-comment-tree",
-  type: l.COMMAND,
-  async handler(s, t) {
-    if (!t)
+  type: CommandType.COMMAND,
+  async handler(accessor, params) {
+    if (!params)
       return !1;
-    const e = s.get(i), n = s.get(C), o = s.get(p), { unitId: r, subUnitId: a, commentId: d } = t, m = e.getCommentWithChildren(r, a, d);
-    return !m || !await o.deleteComment(r, a, m.root.threadId, d) ? !1 : await n.executeCommand(N.id, {
-      unitId: r,
-      subUnitId: a,
-      commentId: m.root.id
+    const threadCommentModel = accessor.get(ThreadCommentModel), commandService = accessor.get(ICommandService), dataSourceService = accessor.get(IThreadCommentDataSourceService), { unitId, subUnitId, commentId } = params, commentWithChildren = threadCommentModel.getCommentWithChildren(unitId, subUnitId, commentId);
+    return !commentWithChildren || !await dataSourceService.deleteComment(unitId, subUnitId, commentWithChildren.root.threadId, commentId) ? !1 : await commandService.executeCommand(DeleteCommentMutation.id, {
+      unitId,
+      subUnitId,
+      commentId: commentWithChildren.root.id
     });
   }
-}, me = "thread-comment.config", R = {};
-var ce = Object.defineProperty, de = Object.getOwnPropertyDescriptor, ie = (s, t, e, n) => {
-  for (var o = n > 1 ? void 0 : n ? de(t, e) : t, r = s.length - 1, a; r >= 0; r--)
-    (a = s[r]) && (o = (n ? a(t, e, o) : a(o)) || o);
-  return n && o && ce(t, e, o), o;
-}, y = (s, t) => (e, n) => t(e, n, s), M;
-let D = (M = class extends H {
-  constructor(s = R, t, e, n) {
-    super(), this._config = s, this._injector = t, this._commandService = e, this._configService = n;
-    const { ...o } = J(
+}, THREAD_COMMENT_PLUGIN_CONFIG_KEY = "thread-comment.config", defaultPluginConfig = {};
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), _a3;
+let UniverThreadCommentPlugin = (_a3 = class extends Plugin {
+  constructor(_config = defaultPluginConfig, _injector, _commandService, _configService) {
+    super(), this._config = _config, this._injector = _injector, this._commandService = _commandService, this._configService = _configService;
+    const { ...rest } = merge(
       {},
-      R,
+      defaultPluginConfig,
       this._config
     );
-    this._configService.setConfig(me, o);
+    this._configService.setConfig(THREAD_COMMENT_PLUGIN_CONFIG_KEY, rest);
   }
   onStarting() {
-    var s;
-    b([
-      [p, { useClass: F }],
-      [i],
-      [S]
-    ], (s = this._config) == null ? void 0 : s.overrides).forEach(
-      (t) => {
-        this._injector.add(t);
+    var _a4;
+    mergeOverrideWithDependencies([
+      [IThreadCommentDataSourceService, { useClass: ThreadCommentDataSourceService }],
+      [ThreadCommentModel],
+      [ThreadCommentResourceController]
+    ], (_a4 = this._config) == null ? void 0 : _a4.overrides).forEach(
+      (d) => {
+        this._injector.add(d);
       }
     ), [
-      ne,
-      oe,
-      ae,
-      re,
-      se,
-      P,
-      $,
-      te,
-      N,
-      x
-    ].forEach((t) => {
-      this._commandService.registerCommand(t);
-    }), this._injector.get(S);
-  }
-}, u(M, "pluginName", w), u(M, "type", G.UNIVER_UNKNOWN), M);
-D = ie([
-  y(1, g(Y)),
-  y(2, C),
-  y(3, K)
-], D);
-function pe(s) {
-  return B(s).format("YYYY/MM/DD HH:mm");
+      AddCommentCommand,
+      UpdateCommentCommand,
+      DeleteCommentCommand,
+      ResolveCommentCommand,
+      DeleteCommentTreeCommand,
+      AddCommentMutation,
+      UpdateCommentMutation,
+      UpdateCommentRefMutation,
+      DeleteCommentMutation,
+      ResolveCommentMutation
+    ].forEach((command) => {
+      this._commandService.registerCommand(command);
+    }), this._injector.get(ThreadCommentResourceController);
+  }
+}, __name(_a3, "UniverThreadCommentPlugin"), __publicField(_a3, "pluginName", TC_PLUGIN_NAME), __publicField(_a3, "type", UniverInstanceType.UNIVER_UNKNOWN), _a3);
+UniverThreadCommentPlugin = __decorateClass([
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, ICommandService),
+  __decorateParam(3, IConfigService)
+], UniverThreadCommentPlugin);
+function getDT(date) {
+  return dayjs(date).format("YYYY/MM/DD HH:mm");
 }
+__name(getDT, "getDT");
 export {
-  ne as AddCommentCommand,
-  P as AddCommentMutation,
-  ae as DeleteCommentCommand,
-  N as DeleteCommentMutation,
-  se as DeleteCommentTreeCommand,
-  p as IThreadCommentDataSourceService,
-  re as ResolveCommentCommand,
-  x as ResolveCommentMutation,
-  w as TC_PLUGIN_NAME,
-  F as ThreadCommentDataSourceService,
-  i as ThreadCommentModel,
-  S as ThreadCommentResourceController,
-  D as UniverThreadCommentPlugin,
-  oe as UpdateCommentCommand,
-  $ as UpdateCommentMutation,
-  te as UpdateCommentRefMutation,
-  pe as getDT
+  AddCommentCommand,
+  AddCommentMutation,
+  DeleteCommentCommand,
+  DeleteCommentMutation,
+  DeleteCommentTreeCommand,
+  IThreadCommentDataSourceService,
+  ResolveCommentCommand,
+  ResolveCommentMutation,
+  TC_PLUGIN_NAME,
+  ThreadCommentDataSourceService,
+  ThreadCommentModel,
+  ThreadCommentResourceController,
+  UniverThreadCommentPlugin,
+  UpdateCommentCommand,
+  UpdateCommentMutation,
+  UpdateCommentRefMutation,
+  getDT
 };