jupyterlab-chat 0.24.0 → 0.24.1

package/lib/__tests__/model.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/model.spec.js

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import { LabChatModel } from '../model';
+import { YChat } from '../ychat';
+const flushPromises = () => new Promise(resolve => setTimeout(resolve, 0));
+const TEST_USER = {
+    username: 'test-user',
+    name: 'Test User',
+    display_name: 'Test',
+    initials: 'TU',
+    color: '#aabbcc'
+};
+function makeWidgetConfig() {
+    const owner = {};
+    owner.config = {};
+    owner.configChanged = new Signal(owner);
+    return owner;
+}
+describe('LabChatModel', () => {
+    let sharedModel;
+    let model;
+    beforeEach(() => {
+        sharedModel = YChat.create();
+        model = new LabChatModel({
+            widgetConfig: makeWidgetConfig(),
+            user: TEST_USER,
+            sharedModel
+        });
+        // Resolve the ready promise so messagesInserted can proceed.
+        model.id = UUID.uuid4();
+    });
+    afterEach(() => {
+        Signal.clearData(model);
+        sharedModel.dispose();
+    });
+    describe('message attribute updates from shared model', () => {
+        it('should reflect a body change', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: 'original',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: 'updated',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            expect(model.messages[0].body).toBe('updated');
+        });
+        it('should reflect a mime_model change', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const mimeModel = { data: { 'text/plain': 'streamed output' } };
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username,
+                mime_model: mimeModel
+            });
+            await flushPromises();
+            expect(model.messages[0].mime_model).toEqual(mimeModel);
+        });
+        it('should not set edited when only mime_model changes', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username,
+                mime_model: { data: { 'text/plain': 'streamed output' } }
+            });
+            await flushPromises();
+            expect(model.messages[0].edited).toBeUndefined();
+        });
+    });
+    describe('rerender tracking', () => {
+        it('should replace renderedDelegate when mime_model changes', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const delegateBefore = model.messages[0].renderedDelegate;
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: '',
+                time: 1000,
+                sender: TEST_USER.username,
+                mime_model: { data: { 'text/plain': 'streamed output' } }
+            });
+            await flushPromises();
+            expect(model.messages[0].renderedDelegate).not.toBe(delegateBefore);
+        });
+        it('should not replace renderedDelegate when only edited changes', async () => {
+            const id = UUID.uuid4();
+            sharedModel.addMessage({
+                type: 'msg',
+                id,
+                body: 'hello',
+                time: 1000,
+                sender: TEST_USER.username
+            });
+            await flushPromises();
+            const delegateBefore = model.messages[0].renderedDelegate;
+            sharedModel.updateMessage(0, {
+                type: 'msg',
+                id,
+                body: 'hello',
+                time: 1000,
+                sender: TEST_USER.username,
+                edited: true
+            });
+            await flushPromises();
+            expect(model.messages[0].renderedDelegate).toBe(delegateBefore);
+        });
+    });
+});

package/lib/model.js

@@ -196,7 +196,8 @@ export class LabChatModel extends AbstractChatModel {
                             'raw_time',
                             'deleted',
                             'edited',
-                            'metadata'
+                            'metadata',
+                            'mime_model'
                         ].includes(key)) {
                             const update = {};
                             update[key] = value;
@@ -353,16 +354,20 @@ export class LabChatModel extends AbstractChatModel {
         });
     }
     sendMessage(message) {
-        var _a, _b, _c, _d;
-        if (!message.body && !message.mime_model && !((_a = message.attachments) === null || _a === void 0 ? void 0 : _a.length)) {
+        var _a, _b, _c, _d, _e;
+        // Allow empty message for bot only, as it may be streamed later.
+        if (!message.body &&
+            !message.mime_model &&
+            !((_a = message.attachments) === null || _a === void 0 ? void 0 : _a.length) &&
+            !((_b = message.sender) === null || _b === void 0 ? void 0 : _b.bot)) {
             return null;
         }
         this._resetWritingStatus();
         if (this._timeoutWriting !== null) {
             window.clearTimeout(this._timeoutWriting);
         }
-        const body = (_b = message.body) !== null && _b !== void 0 ? _b : '';
-        const user = (_c = message.sender) !== null && _c !== void 0 ? _c : this._user;
+        const body = (_c = message.body) !== null && _c !== void 0 ? _c : '';
+        const user = (_d = message.sender) !== null && _d !== void 0 ? _d : this._user;
         const msg = {
             type: 'msg',
             id: UUID.uuid4(),
@@ -380,7 +385,7 @@ export class LabChatModel extends AbstractChatModel {
             this.sharedModel.setUser(user);
         }
         // Add the attachments to the message.
-        const attachmentIds = (_d = message.attachments) === null || _d === void 0 ? void 0 : _d.map(attachment => this.sharedModel.setAttachment(attachment));
+        const attachmentIds = (_e = message.attachments) === null || _e === void 0 ? void 0 : _e.map(attachment => this.sharedModel.setAttachment(attachment));
         if (attachmentIds === null || attachmentIds === void 0 ? void 0 : attachmentIds.length) {
             msg.attachments = attachmentIds;
         }
@@ -421,6 +426,10 @@ export class LabChatModel extends AbstractChatModel {
                 edited: true
             };
         }
+        // Update the mime model.
+        if (updatedMessage.mime_model) {
+            message.mime_model = updatedMessage.mime_model;
+        }
         // Update the attachments.
         const attachmentIds = (_a = updatedMessage.attachments) === null || _a === void 0 ? void 0 : _a.map(attachment => this.sharedModel.setAttachment(attachment));
         if (attachmentIds === null || attachmentIds === void 0 ? void 0 : attachmentIds.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jupyterlab-chat",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "description": "The library to build a chat based on shared document",
   "keywords": [
     "jupyter",
@@ -42,7 +42,7 @@
     "watch:src": "tsc -w --sourceMap"
   },
   "dependencies": {
-    "@jupyter/chat": "^0.24.0",
+    "@jupyter/chat": "^0.24.1",
     "@jupyter/collaborative-drive": "^4.4.0 || ^5.0.0",
     "@jupyter/ydoc": "^3.0.0 || ^4.0.0",
     "@jupyterlab/application": "^4.5.0",

package/src/__tests__/model.spec.ts

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+
+import { LabChatModel } from '../model';
+import { IWidgetConfig } from '../token';
+import { YChat } from '../ychat';
+
+const flushPromises = () => new Promise(resolve => setTimeout(resolve, 0));
+
+const TEST_USER = {
+  username: 'test-user',
+  name: 'Test User',
+  display_name: 'Test',
+  initials: 'TU',
+  color: '#aabbcc'
+};
+
+function makeWidgetConfig(): IWidgetConfig {
+  const owner = {} as IWidgetConfig;
+  owner.config = {};
+  (owner as any).configChanged = new Signal<IWidgetConfig, any>(owner);
+  return owner;
+}
+
+describe('LabChatModel', () => {
+  let sharedModel: YChat;
+  let model: LabChatModel;
+
+  beforeEach(() => {
+    sharedModel = YChat.create();
+    model = new LabChatModel({
+      widgetConfig: makeWidgetConfig(),
+      user: TEST_USER,
+      sharedModel
+    });
+    // Resolve the ready promise so messagesInserted can proceed.
+    model.id = UUID.uuid4();
+  });
+
+  afterEach(() => {
+    Signal.clearData(model);
+    sharedModel.dispose();
+  });
+
+  describe('message attribute updates from shared model', () => {
+    it('should reflect a body change', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: 'original',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: 'updated',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      expect(model.messages[0].body).toBe('updated');
+    });
+
+    it('should reflect a mime_model change', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const mimeModel = { data: { 'text/plain': 'streamed output' } };
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username,
+        mime_model: mimeModel
+      });
+      await flushPromises();
+
+      expect(model.messages[0].mime_model).toEqual(mimeModel);
+    });
+
+    it('should not set edited when only mime_model changes', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username,
+        mime_model: { data: { 'text/plain': 'streamed output' } }
+      });
+      await flushPromises();
+
+      expect(model.messages[0].edited).toBeUndefined();
+    });
+  });
+
+  describe('rerender tracking', () => {
+    it('should replace renderedDelegate when mime_model changes', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const delegateBefore = model.messages[0].renderedDelegate;
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: '',
+        time: 1000,
+        sender: TEST_USER.username,
+        mime_model: { data: { 'text/plain': 'streamed output' } }
+      });
+      await flushPromises();
+
+      expect(model.messages[0].renderedDelegate).not.toBe(delegateBefore);
+    });
+
+    it('should not replace renderedDelegate when only edited changes', async () => {
+      const id = UUID.uuid4();
+      sharedModel.addMessage({
+        type: 'msg',
+        id,
+        body: 'hello',
+        time: 1000,
+        sender: TEST_USER.username
+      });
+      await flushPromises();
+
+      const delegateBefore = model.messages[0].renderedDelegate;
+
+      sharedModel.updateMessage(0, {
+        type: 'msg',
+        id,
+        body: 'hello',
+        time: 1000,
+        sender: TEST_USER.username,
+        edited: true
+      });
+      await flushPromises();
+
+      expect(model.messages[0].renderedDelegate).toBe(delegateBefore);
+    });
+  });
+});

package/src/model.ts

@@ -234,7 +234,13 @@ export class LabChatModel
   }
 
   sendMessage(message: INewMessage): string | null {
-    if (!message.body && !message.mime_model && !message.attachments?.length) {
+    // Allow empty message for bot only, as it may be streamed later.
+    if (
+      !message.body &&
+      !message.mime_model &&
+      !message.attachments?.length &&
+      !message.sender?.bot
+    ) {
       return null;
     }
     this._resetWritingStatus();
@@ -316,6 +322,11 @@ export class LabChatModel
       };
     }
 
+    // Update the mime model.
+    if (updatedMessage.mime_model) {
+      message.mime_model = updatedMessage.mime_model;
+    }
+
     // Update the attachments.
     const attachmentIds = updatedMessage.attachments?.map(attachment =>
       this.sharedModel.setAttachment(attachment)
@@ -551,7 +562,8 @@ export class LabChatModel
               'raw_time',
               'deleted',
               'edited',
-              'metadata'
+              'metadata',
+              'mime_model'
             ].includes(key)
           ) {
             const update: Partial<IMessageContent> = {};