@univerjs/sheets-thread-comment 0.4.1 → 0.4.2-nightly.202410301606

package/README.md

@@ -4,93 +4,24 @@
 
 | Package Name | UMD Namespace | Version | License | Downloads | Contains CSS | Contains i18n locales |
 | --- | --- | --- | --- | --- | :---: | :---: |
-| `@univerjs/sheets-thread-comment` | `UniverSheetsThreadComment` | [![][npm-version-shield]][npm-version-link] | ![][npm-license-shield] | ![][npm-downloads-shield] | ⭕️ | ⭕️ |
+| `@univerjs/sheets-thread-comment` | `UniverSheetsThreadCommentBase` | [![][npm-version-shield]][npm-version-link] | ![][npm-license-shield] | ![][npm-downloads-shield] | ❌ | ❌ |
 
 ## Introduction
 
-`@univerjs/sheets-thread-comment` provides the comment/annotation function of Univer Sheets.
+`@univerjs/sheets-thread-comment` core package for sheet comment. For using, please refer to [@univerjs/sheets-thread-comment](../sheets-thread-comment/README.md)
 
 ## Usage
 
 ### Installation
 
 ```shell
-# Use npm
+# Using npm
 npm install @univerjs/sheets-thread-comment
 
-# Use pnpm
+# Using pnpm
 pnpm add @univerjs/sheets-thread-comment
 ```
 
-### Register the plugin
-
-```typescript
-import { UniverSheetsThreadCommentPlugin, IThreadCommentMentionDataService} from '@univerjs/sheets-thread-comment';
-
-const mockUser = {
-    userID: 'mockId',
-    name: 'MockUser',
-    avatar: 'icon-url',
-    anonymous: false,
-    canBindAnonymous: false,
-};
-
-class CustomMentionDataService implements IThreadCommentMentionDataService {
-    trigger: string = '@';
-
-     // Get the common interface implementation of the mentioned user
-    async getMentions(search: string) {
-        return [
-            {
-                id: mockUser.userID,
-                label: mockUser.name,
-                type: 'user',
-                icon: mockUser.avatar,
-            },
-            {
-                id: '2',
-                label: 'User2',
-                type: 'user',
-                icon: mockUser.avatar,
-            },
-        ];
-    }
-}
-
-univer.registerPlugin(UniverSheetsThreadCommentPlugin, {
-    overrides: [[IThreadCommentMentionDataService, { useClass: CustomMentionDataService }]],
-});
-```
-
-### API
-```typescript
-import {
-    AddCommentCommand,
-    DeleteCommentCommand,
-    UpdateCommentCommand,
-    ResolveCommentCommand,
-    DeleteCommentTreeCommand,
-} from '@univerjs/sheets-thread-comment';
-import type {
-    IAddCommentCommandParams,
-    IDeleteCommentCommandParams,
-    IResolveCommentCommandParams,
-    IUpdateCommentCommandParams,
-    IDeleteCommentTreeCommandParams,
-} from '@univerjs/sheets-thread-comment';
-
-// Add comment by command
-const commandService = univer.__getInjector().get(ICommandService);
-
-commandService.executeCommand(AddCommentCommand.id, {
-    unitId: 'unitId',
-    subUnitId: 'subUnitId',
-    comment: {
-        // comment content
-    },
-} as IAddCommentCommandParams);
-```
-
 <!-- Links -->
 [npm-version-shield]: https://img.shields.io/npm/v/@univerjs/sheets-thread-comment?style=flat-square
 [npm-version-link]: https://npmjs.com/package/@univerjs/sheets-thread-comment

package/lib/es/facade.js

@@ -0,0 +1,226 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+import { Inject, Injector, UniverInstanceType, ICommandService, IUniverInstanceService, UserManagerService, Tools, toDisposable } from "@univerjs/core";
+import { FRange, FWorkbook, FWorksheet } from "@univerjs/sheets/facade";
+import { DeleteCommentTreeCommand, DeleteCommentCommand, getDT, UpdateCommentCommand, ResolveCommentCommand, AddCommentCommand, ThreadCommentModel } from "@univerjs/thread-comment";
+import { S as SheetsThreadCommentModel } from "../sheets-thread-comment.model-17mh6Jez.mjs";
+import { deserializeRangeWithSheet } from "@univerjs/engine-formula";
+import { filter } from "rxjs";
+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"), _a;
+let FThreadComment = (_a = class {
+  constructor(_thread, _parent, _injector, _commandService, _univerInstanceService, _threadCommentModel) {
+    this._thread = _thread, this._parent = _parent, this._injector = _injector, this._commandService = _commandService, this._univerInstanceService = _univerInstanceService, this._threadCommentModel = _threadCommentModel;
+  }
+  _getRef() {
+    var _a2;
+    const ref = ((_a2 = this._parent) == null ? void 0 : _a2.ref) || this._thread.ref;
+    return deserializeRangeWithSheet(ref).range;
+  }
+  /**
+   * Whether the comment is a root comment
+   * @returns Whether the comment is a root comment
+   */
+  getIsRoot() {
+    return !this._parent;
+  }
+  /**
+   * Get the comment data
+   * @returns The comment data
+   */
+  getCommentData() {
+    const { children, ...comment } = this._thread;
+    return comment;
+  }
+  /**
+   * Get the replies of the comment
+   * @returns the replies of the comment
+   */
+  getReplies() {
+    var _a2;
+    const range = this._getRef(), comments = this._threadCommentModel.getCommentWithChildren(this._thread.unitId, this._thread.subUnitId, range.startRow, range.startColumn);
+    return (_a2 = comments == null ? void 0 : comments.children) == null ? void 0 : _a2.map((child) => this._injector.createInstance(FThreadComment, child));
+  }
+  /**
+   * Get the range of the comment
+   * @returns The range of the comment
+   */
+  getRange() {
+    const workbook = this._univerInstanceService.getUnit(this._thread.unitId, UniverInstanceType.UNIVER_SHEET);
+    if (!workbook)
+      return null;
+    const worksheet = workbook.getSheetBySheetId(this._thread.subUnitId);
+    if (!worksheet)
+      return null;
+    const range = this._getRef();
+    return this._injector.createInstance(FRange, workbook, worksheet, range);
+  }
+  /**
+   * Get the content of the comment
+   * @returns The content of the comment
+   */
+  getContent() {
+    return this._thread.text;
+  }
+  /**
+   * Delete the comment and it's replies
+   * @returns success or not
+   */
+  delete() {
+    return this._commandService.executeCommand(
+      this.getIsRoot() ? DeleteCommentTreeCommand.id : DeleteCommentCommand.id,
+      {
+        commentId: this._thread.id,
+        unitId: this._thread.unitId,
+        subUnitId: this._thread.subUnitId
+      }
+    );
+  }
+  /**
+   * Update the comment content
+   * @param content The new content of the comment
+   * @returns success or not
+   */
+  async update(content) {
+    const dt = getDT();
+    return await this._commandService.executeCommand(
+      UpdateCommentCommand.id,
+      {
+        unitId: this._thread.unitId,
+        subUnitId: this._thread.subUnitId,
+        payload: {
+          commentId: this._thread.id,
+          text: content,
+          updated: !0,
+          updateT: dt
+        }
+      }
+    );
+  }
+  /**
+   * Resolve the comment
+   * @param resolved Whether the comment is resolved
+   * @returns success or not
+   */
+  resolve(resolved) {
+    return this._commandService.executeCommand(
+      ResolveCommentCommand.id,
+      {
+        unitId: this._thread.unitId,
+        subUnitId: this._thread.subUnitId,
+        commentId: this._thread.id,
+        resolved: resolved != null ? resolved : !this._thread.resolved
+      }
+    );
+  }
+}, __name(_a, "FThreadComment"), _a);
+FThreadComment = __decorateClass([
+  __decorateParam(2, Inject(Injector)),
+  __decorateParam(3, ICommandService),
+  __decorateParam(4, IUniverInstanceService),
+  __decorateParam(5, Inject(SheetsThreadCommentModel))
+], FThreadComment);
+const _FRangeCommentMixin = class _FRangeCommentMixin extends FRange {
+  getComment() {
+    const sheetsTheadCommentModel = this._injector.get(SheetsThreadCommentModel), unitId = this._workbook.getUnitId(), sheetId = this._worksheet.getSheetId(), commentId = sheetsTheadCommentModel.getByLocation(unitId, sheetId, this._range.startRow, this._range.startColumn);
+    if (!commentId)
+      return null;
+    const comment = sheetsTheadCommentModel.getComment(unitId, sheetId, commentId);
+    return comment ? this._injector.createInstance(FThreadComment, comment) : null;
+  }
+  addComment(content) {
+    var _a2;
+    const injector = this._injector, currentComment = (_a2 = this.getComment()) == null ? void 0 : _a2.getCommentData(), commentService = injector.get(ICommandService), userService = injector.get(UserManagerService), unitId = this._workbook.getUnitId(), sheetId = this._worksheet.getSheetId(), refStr = `${Tools.chatAtABC(this._range.startColumn)}${this._range.startRow + 1}`, currentUser = userService.getCurrentUser();
+    return commentService.executeCommand(AddCommentCommand.id, {
+      unitId,
+      subUnitId: sheetId,
+      comment: {
+        text: content,
+        attachments: [],
+        dT: getDT(),
+        id: Tools.generateRandomId(),
+        ref: refStr,
+        personId: currentUser.userID,
+        parentId: currentComment == null ? void 0 : currentComment.id,
+        unitId,
+        subUnitId: sheetId,
+        threadId: currentComment == null ? void 0 : currentComment.threadId
+      }
+    });
+  }
+  clearComment() {
+    var _a2;
+    const injector = this._injector, currentComment = (_a2 = this.getComment()) == null ? void 0 : _a2.getCommentData(), commentService = injector.get(ICommandService), unitId = this._workbook.getUnitId(), sheetId = this._worksheet.getSheetId();
+    return currentComment ? commentService.executeCommand(DeleteCommentTreeCommand.id, {
+      unitId,
+      subUnitId: sheetId,
+      threadId: currentComment.threadId,
+      commentId: currentComment.id
+    }) : Promise.resolve(!0);
+  }
+};
+__name(_FRangeCommentMixin, "FRangeCommentMixin");
+let FRangeCommentMixin = _FRangeCommentMixin;
+FRange.extend(FRangeCommentMixin);
+const _FWorkbookThreadCommentMixin = class _FWorkbookThreadCommentMixin extends FWorkbook {
+  _initialize() {
+    Object.defineProperty(this, "_threadCommentModel", {
+      get() {
+        return this._injector.get(ThreadCommentModel);
+      }
+    });
+  }
+  onThreadCommentChange(callback) {
+    return toDisposable(this._threadCommentModel.commentUpdate$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
+  }
+  onBeforeAddThreadComment(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === AddCommentCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
+          return;
+        if (callback(params, options) === !1)
+          throw new Error("Command is stopped by the hook onBeforeAddThreadComment");
+      }
+    }));
+  }
+  onBeforeUpdateThreadComment(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === UpdateCommentCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
+          return;
+        if (callback(params, options) === !1)
+          throw new Error("Command is stopped by the hook onBeforeUpdateThreadComment");
+      }
+    }));
+  }
+  onBeforeDeleteThreadComment(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === DeleteCommentCommand.id || commandInfo.id === DeleteCommentTreeCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
+          return;
+        if (callback(params, options) === !1)
+          throw new Error("Command is stopped by the hook onBeforeDeleteThreadComment");
+      }
+    }));
+  }
+};
+__name(_FWorkbookThreadCommentMixin, "FWorkbookThreadCommentMixin");
+let FWorkbookThreadCommentMixin = _FWorkbookThreadCommentMixin;
+FWorkbook.extend(FWorkbookThreadCommentMixin);
+const _FWorksheetCommentMixin = class _FWorksheetCommentMixin extends FWorksheet {
+  getComments() {
+    return this._injector.get(SheetsThreadCommentModel).getSubUnitAll(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((comment) => this._injector.createInstance(FThreadComment, comment));
+  }
+};
+__name(_FWorksheetCommentMixin, "FWorksheetCommentMixin");
+let FWorksheetCommentMixin = _FWorksheetCommentMixin;
+FWorksheet.extend(FWorksheetCommentMixin);
+export {
+  FThreadComment
+};