@jupyter/chat 0.9.0 → 0.10.0

package/lib/__tests__/mocks.d.ts

@@ -0,0 +1,9 @@
+import { AbstractChatContext, AbstractChatModel, IChatModel, IChatContext } from '../model';
+import { INewMessage } from '../types';
+export declare class MockChatContext extends AbstractChatContext implements IChatContext {
+    get users(): never[];
+}
+export declare class MockChatModel extends AbstractChatModel implements IChatModel {
+    sendMessage(message: INewMessage): Promise<boolean | void> | boolean | void;
+    createChatContext(): IChatContext;
+}

package/lib/__tests__/mocks.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { AbstractChatContext, AbstractChatModel } from '../model';
+export class MockChatContext extends AbstractChatContext {
+    get users() {
+        return [];
+    }
+}
+export class MockChatModel extends AbstractChatModel {
+    sendMessage(message) {
+        // No-op
+    }
+    createChatContext() {
+        return new MockChatContext({ model: this });
+    }
+}

package/lib/__tests__/model.spec.js

@@ -5,25 +5,32 @@
 /**
  * Example of [Jest](https://jestjs.io/docs/getting-started) unit tests
  */
-import { ChatModel } from '../model';
+import { AbstractChatModel } from '../model';
+import { MockChatModel, MockChatContext } from './mocks';
 describe('test chat model', () => {
     describe('model instantiation', () => {
-        it('should create a ChatModel', () => {
-            const model = new ChatModel();
-            expect(model).toBeInstanceOf(ChatModel);
+        it('should create an AbstractChatModel', () => {
+            const model = new MockChatModel();
+            expect(model).toBeInstanceOf(AbstractChatModel);
         });
-        it('should dispose a ChatModel', () => {
-            const model = new ChatModel();
+        it('should dispose an AbstractChatModel', () => {
+            const model = new MockChatModel();
             model.dispose();
             expect(model.isDisposed).toBeTruthy();
         });
     });
     describe('incoming message', () => {
-        class TestChat extends ChatModel {
+        class TestChat extends AbstractChatModel {
             formatChatMessage(message) {
                 message.body = 'formatted msg';
                 return message;
             }
+            sendMessage(message) {
+                // No-op
+            }
+            createChatContext() {
+                return new MockChatContext({ model: this });
+            }
         }
         let model;
         let messages;
@@ -38,7 +45,7 @@ describe('test chat model', () => {
             messages = [];
         });
         it('should signal incoming message', () => {
-            model = new ChatModel();
+            model = new MockChatModel();
             model.messagesUpdated.connect((sender) => {
                 expect(sender).toBe(model);
                 messages = model.messages;
@@ -61,11 +68,11 @@ describe('test chat model', () => {
     });
     describe('model config', () => {
         it('should have empty config', () => {
-            const model = new ChatModel();
+            const model = new MockChatModel();
             expect(model.config.sendWithShiftEnter).toBeUndefined();
         });
         it('should allow config', () => {
-            const model = new ChatModel({ config: { sendWithShiftEnter: true } });
+            const model = new MockChatModel({ config: { sendWithShiftEnter: true } });
             expect(model.config.sendWithShiftEnter).toBeTruthy();
         });
     });

package/lib/__tests__/widgets.spec.js

@@ -6,21 +6,21 @@
  * Example of [Jest](https://jestjs.io/docs/getting-started) unit tests
  */
 import { RenderMimeRegistry } from '@jupyterlab/rendermime';
-import { ChatModel } from '../model';
 import { ChatWidget } from '../widgets/chat-widget';
+import { MockChatModel } from './mocks';
 describe('test chat widget', () => {
     let model;
     let rmRegistry;
     beforeEach(() => {
-        model = new ChatModel();
+        model = new MockChatModel();
         rmRegistry = new RenderMimeRegistry();
     });
     describe('model instantiation', () => {
-        it('should create a ChatModel', () => {
+        it('should create an AbstractChatModel', () => {
             const widget = new ChatWidget({ model, rmRegistry });
             expect(widget).toBeInstanceOf(ChatWidget);
         });
-        it('should dispose a ChatModel', () => {
+        it('should dispose an AbstractChatModel', () => {
             const widget = new ChatWidget({ model, rmRegistry });
             widget.dispose();
             expect(widget.isDisposed).toBeTruthy();

package/lib/chat-commands/types.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { LabIcon } from '@jupyterlab/ui-components';
 import { IInputModel } from '../input-model';
 export type ChatCommand = {
@@ -14,7 +15,7 @@ export type ChatCommand = {
      * If set, this will be rendered as the icon for the command in the chat
      * commands menu. Jupyter Chat will choose a default if this is unset.
      */
-    icon?: LabIcon | string;
+    icon?: LabIcon | JSX.Element | string | null;
     /**
      * If set, this will be rendered as the description for the command in the
      * chat commands menu. Jupyter Chat will choose a default if this is unset.

package/lib/components/chat-input.d.ts

@@ -13,7 +13,7 @@ export declare namespace ChatInput {
      */
     interface IProps {
         /**
-         * The chat model.
+         * The input model.
          */
         model: IInputModel;
         /**

package/lib/components/chat-messages.js

@@ -13,6 +13,7 @@ import { ChatInput } from './chat-input';
 import { MarkdownRenderer } from './markdown-renderer';
 import { ScrollContainer } from './scroll-container';
 import { InputModel } from '../input-model';
+import { replaceSpanToMention } from '../utils';
 const MESSAGES_BOX_CLASS = 'jp-chat-messages-container';
 const MESSAGE_CLASS = 'jp-chat-message';
 const MESSAGE_STACKED_CLASS = 'jp-chat-message-stacked';
@@ -246,16 +247,27 @@ export const ChatMessage = forwardRef((props, ref) => {
     // Create an input model only if the message is edited.
     useEffect(() => {
         if (edit && canEdit) {
-            setInputModel(new InputModel({
-                onSend: (input, model) => updateMessage(message.id, input, model),
-                onCancel: () => cancelEdition(),
-                value: message.body,
-                config: {
-                    sendWithShiftEnter: model.config.sendWithShiftEnter
-                },
-                attachments: message.attachments,
-                documentManager: model.documentManager
-            }));
+            setInputModel(() => {
+                var _a;
+                let body = message.body;
+                (_a = message.mentions) === null || _a === void 0 ? void 0 : _a.forEach(user => {
+                    body = replaceSpanToMention(body, user);
+                });
+                return new InputModel({
+                    chatContext: model.createChatContext(),
+                    onSend: (input, model) => updateMessage(message.id, input, model),
+                    onCancel: () => cancelEdition(),
+                    value: body,
+                    activeCellManager: model.activeCellManager,
+                    selectionWatcher: model.selectionWatcher,
+                    documentManager: model.documentManager,
+                    config: {
+                        sendWithShiftEnter: model.config.sendWithShiftEnter
+                    },
+                    attachments: message.attachments,
+                    mentions: message.mentions
+                });
+            });
         }
         else {
             setInputModel(null);
@@ -274,6 +286,7 @@ export const ChatMessage = forwardRef((props, ref) => {
         const updatedMessage = { ...message };
         updatedMessage.body = input;
         updatedMessage.attachments = inputModel.attachments;
+        updatedMessage.mentions = inputModel.mentions;
         model.updateMessage(id, updatedMessage);
         setEdit(false);
     };

package/lib/components/input/use-chat-commands.js

@@ -2,9 +2,9 @@
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
-import React from 'react';
-import { useEffect, useState } from 'react';
+import { LabIcon } from '@jupyterlab/ui-components';
 import { Box } from '@mui/material';
+import React, { useEffect, useState } from 'react';
 /**
  * A hook which automatically returns the list of command options given the
  * current input and chat command registry.
@@ -83,7 +83,7 @@ export function useChatCommands(inputModel, chatCommandRegistry) {
             getOptionLabel: (command) => command.name,
             renderOption: (defaultProps, command, __, ___) => {
                 const { key, ...listItemProps } = defaultProps;
-                const commandIcon = (React.createElement("span", null, typeof command.icon === 'object' ? (React.createElement(command.icon.react, null)) : (command.icon)));
+                const commandIcon = React.isValidElement(command.icon) ? (command.icon) : (React.createElement("span", null, command.icon instanceof LabIcon ? (React.createElement(command.icon.react, null)) : (command.icon)));
                 return (React.createElement(Box, { key: key, component: "li", ...listItemProps },
                     commandIcon,
                     React.createElement("p", { className: "jp-chat-command-name" }, command.name),

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from './active-cell-manager';
+export * from './chat-commands';
 export * from './components';
 export * from './icons';
 export * from './input-model';
@@ -9,4 +10,3 @@ export * from './types';
 export * from './widgets/chat-error';
 export * from './widgets/chat-sidebar';
 export * from './widgets/chat-widget';
-export * from './chat-commands';

package/lib/index.js

@@ -3,6 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 export * from './active-cell-manager';
+export * from './chat-commands';
 export * from './components';
 export * from './icons';
 export * from './input-model';
@@ -13,4 +14,3 @@ export * from './types';
 export * from './widgets/chat-error';
 export * from './widgets/chat-sidebar';
 export * from './widgets/chat-widget';
-export * from './chat-commands';

package/lib/input-model.d.ts

@@ -1,13 +1,18 @@
+import { IDocumentManager } from '@jupyterlab/docmanager';
 import { IDisposable } from '@lumino/disposable';
 import { ISignal } from '@lumino/signaling';
 import { IActiveCellManager } from './active-cell-manager';
 import { ISelectionWatcher } from './selection-watcher';
-import { IAttachment } from './types';
-import { IDocumentManager } from '@jupyterlab/docmanager';
+import { IChatContext } from './model';
+import { IAttachment, IUser } from './types';
 /**
  * The chat input interface.
  */
 export interface IInputModel extends IDisposable {
+    /**
+     * The chat context (a readonly subset of the chat model).
+     */
+    readonly chatContext: IChatContext;
     /**
      * Function to send a message.
      */
@@ -93,12 +98,32 @@ export interface IInputModel extends IDisposable {
      * Replace the current word in the input with a new one.
      */
     replaceCurrentWord(newWord: string): void;
+    /**
+     * The mentioned user list.
+     */
+    readonly mentions: IUser[];
+    /**
+     * Add user mention.
+     */
+    addMention?(user: IUser): void;
+    /**
+     * Remove a user mention.
+     */
+    removeMention(user: IUser): void;
+    /**
+     * Clear mentions list.
+     */
+    clearMentions(): void;
 }
 /**
  * The input model.
  */
 export declare class InputModel implements IInputModel {
     constructor(options: InputModel.IOptions);
+    /**
+     * The chat context (a readonly subset of the chat model);
+     */
+    get chatContext(): IChatContext;
     /**
      * Function to send a message.
      */
@@ -186,6 +211,22 @@ export declare class InputModel implements IInputModel {
      * Replace the current word in the input with a new one.
      */
     replaceCurrentWord(newWord: string): void;
+    /**
+     * The mentioned user list.
+     */
+    get mentions(): IUser[];
+    /**
+     * Add a user mention.
+     */
+    addMention(user: IUser): void;
+    /**
+     * Remove a user mention.
+     */
+    removeMention(user: IUser): void;
+    /**
+     * Clear mentions list.
+     */
+    clearMentions: () => void;
     /**
      * Dispose the input model.
      */
@@ -195,10 +236,12 @@ export declare class InputModel implements IInputModel {
      */
     get isDisposed(): boolean;
     private _onSend;
+    private _chatContext;
     private _value;
     private _cursorIndex;
     private _currentWord;
     private _attachments;
+    private _mentions;
     private _activeCellManager;
     private _selectionWatcher;
     private _documentManager;
@@ -213,6 +256,10 @@ export declare class InputModel implements IInputModel {
 }
 export declare namespace InputModel {
     interface IOptions {
+        /**
+         * The chat context (a readonly subset of the chat model).
+         */
+        chatContext: IChatContext;
         /**
          * The function that should send the message.
          * @param content - the content of the message.
@@ -231,6 +278,10 @@ export declare namespace InputModel {
          * The initial attachments.
          */
         attachments?: IAttachment[];
+        /**
+         * The initial mentions.
+         */
+        mentions?: IUser[];
         /**
          * The current cursor index.
          * This refers to the index of the character in front of the cursor.

package/lib/input-model.js

@@ -46,6 +46,12 @@ export class InputModel {
             this._attachments = [];
             this._attachmentsChanged.emit([]);
         };
+        /**
+         * Clear mentions list.
+         */
+        this.clearMentions = () => {
+            this._mentions = [];
+        };
         this._cursorIndex = null;
         this._currentWord = null;
         this._valueChanged = new Signal(this);
@@ -56,8 +62,10 @@ export class InputModel {
         this._attachmentsChanged = new Signal(this);
         this._isDisposed = false;
         this._onSend = options.onSend;
+        this._chatContext = options.chatContext;
         this._value = options.value || '';
         this._attachments = options.attachments || [];
+        this._mentions = options.mentions || [];
         this.cursorIndex = options.cursorIndex || this.value.length;
         this._activeCellManager = (_a = options.activeCellManager) !== null && _a !== void 0 ? _a : null;
         this._selectionWatcher = (_b = options.selectionWatcher) !== null && _b !== void 0 ? _b : null;
@@ -67,6 +75,12 @@ export class InputModel {
         };
         this.cancel = options.onCancel;
     }
+    /**
+     * The chat context (a readonly subset of the chat model);
+     */
+    get chatContext() {
+        return this._chatContext;
+    }
     /**
      * The entire input value.
      */
@@ -190,6 +204,30 @@ export class InputModel {
         const [start, end] = Private.getCurrentWordBoundaries(this.value, this.cursorIndex);
         this.value = this.value.slice(0, start) + newWord + this.value.slice(end);
     }
+    /**
+     * The mentioned user list.
+     */
+    get mentions() {
+        return this._mentions;
+    }
+    /**
+     * Add a user mention.
+     */
+    addMention(user) {
+        const usernames = this._mentions.map(user => user.username);
+        if (!usernames.includes(user.username)) {
+            this._mentions.push(user);
+        }
+    }
+    /**
+     * Remove a user mention.
+     */
+    removeMention(user) {
+        const index = this._mentions.indexOf(user);
+        if (index > -1) {
+            this._mentions.splice(index, 1);
+        }
+    }
     /**
      * Dispose the input model.
      */

package/lib/model.d.ts

@@ -2,10 +2,10 @@ import { IDocumentManager } from '@jupyterlab/docmanager';
 import { CommandRegistry } from '@lumino/commands';
 import { IDisposable } from '@lumino/disposable';
 import { ISignal } from '@lumino/signaling';
-import { IChatHistory, INewMessage, IChatMessage, IConfig, IUser } from './types';
 import { IActiveCellManager } from './active-cell-manager';
-import { ISelectionWatcher } from './selection-watcher';
 import { IInputModel } from './input-model';
+import { ISelectionWatcher } from './selection-watcher';
+import { IChatHistory, INewMessage, IChatMessage, IConfig, IUser } from './types';
 /**
  * The chat model interface.
  */
@@ -131,17 +131,22 @@ export interface IChatModel extends IDisposable {
      * Update the current writers list.
      */
     updateWriters(writers: IUser[]): void;
+    /**
+     * Create the chat context that will be passed to the input model.
+     */
+    createChatContext(): IChatContext;
 }
 /**
- * The default chat model implementation.
- * It is not able to send or update a message by itself, since it depends on the
- * chosen technology.
+ * An abstract implementation of IChatModel.
+ *
+ * The class inheriting from it must implement at least:
+ * - sendMessage(message: INewMessage)
  */
-export declare class ChatModel implements IChatModel {
+export declare abstract class AbstractChatModel implements IChatModel {
     /**
      * Create a new chat model.
      */
-    constructor(options?: ChatModel.IOptions);
+    constructor(options?: IChatModel.IOptions);
     /**
      * The chat model id.
      */
@@ -219,7 +224,7 @@ export declare class ChatModel implements IChatModel {
      * @param message - the message to send.
      * @returns whether the message has been sent or not.
      */
-    sendMessage(message: INewMessage): Promise<boolean | void> | boolean | void;
+    abstract sendMessage(message: INewMessage): Promise<boolean | void> | boolean | void;
     /**
      * Clear the message list.
      */
@@ -262,6 +267,10 @@ export declare class ChatModel implements IChatModel {
      * This implementation only propagate the list via a signal.
      */
     updateWriters(writers: IUser[]): void;
+    /**
+     * Create the chat context that will be passed to the input model.
+     */
+    abstract createChatContext(): IChatContext;
     /**
      * Add unread messages to the list.
      * @param indexes - list of new indexes.
@@ -299,7 +308,7 @@ export declare class ChatModel implements IChatModel {
 /**
  * The chat model namespace.
  */
-export declare namespace ChatModel {
+export declare namespace IChatModel {
     /**
      * The instantiation options for a ChatModel.
      */
@@ -330,3 +339,39 @@ export declare namespace ChatModel {
         documentManager?: IDocumentManager | null;
     }
 }
+/**
+ * Interface of the chat context, a 'subset' of the model with readonly attribute,
+ * which can be passed to the input model.
+ * This allows third party extensions to get some attribute of the model without
+ * exposing the method that can modify it.
+ */
+export interface IChatContext {
+    /**
+     * The name of the chat.
+     */
+    readonly name: string;
+    /**
+     * A copy of the messages.
+     */
+    readonly messages: IChatMessage[];
+    /**
+     * A list of all users who have connected to this chat.
+     */
+    readonly users: IUser[];
+}
+/**
+ * An abstract base class implementing `IChatContext`. This can be extended into
+ * a complete implementation, as done in `jupyterlab-chat`.
+ */
+export declare abstract class AbstractChatContext implements IChatContext {
+    constructor(options: {
+        model: IChatModel;
+    });
+    get name(): string;
+    get messages(): IChatMessage[];
+    /**
+     * ABSTRACT: Should return a list of users who have connected to this chat.
+     */
+    abstract get users(): IUser[];
+    protected _model: IChatModel;
+}

package/lib/model.js

@@ -4,12 +4,14 @@
  */
 import { Signal } from '@lumino/signaling';
 import { InputModel } from './input-model';
+import { replaceMentionToSpan } from './utils';
 /**
- * The default chat model implementation.
- * It is not able to send or update a message by itself, since it depends on the
- * chosen technology.
+ * An abstract implementation of IChatModel.
+ *
+ * The class inheriting from it must implement at least:
+ * - sendMessage(message: INewMessage)
  */
-export class ChatModel {
+export class AbstractChatModel {
     /**
      * Create a new chat model.
      */
@@ -37,6 +39,7 @@ export class ChatModel {
             ...config
         };
         this._inputModel = new InputModel({
+            chatContext: this.createChatContext(),
             activeCellManager: options.activeCellManager,
             selectionWatcher: options.selectionWatcher,
             documentManager: options.documentManager,
@@ -220,14 +223,6 @@ export class ChatModel {
     get writersChanged() {
         return this._writersChanged;
     }
-    /**
-     * Send a message, to be defined depending on the chosen technology.
-     * Default to no-op.
-     *
-     * @param message - the message to send.
-     * @returns whether the message has been sent or not.
-     */
-    sendMessage(message) { }
     /**
      * Clear the message list.
      */
@@ -255,6 +250,10 @@ export class ChatModel {
      * Can be useful if some actions are required on the message.
      */
     formatChatMessage(message) {
+        var _a;
+        (_a = message.mentions) === null || _a === void 0 ? void 0 : _a.forEach(user => {
+            message.body = replaceMentionToSpan(message.body, user);
+        });
         return message;
     }
     /**
@@ -379,3 +378,18 @@ export class ChatModel {
         }
     }
 }
+/**
+ * An abstract base class implementing `IChatContext`. This can be extended into
+ * a complete implementation, as done in `jupyterlab-chat`.
+ */
+export class AbstractChatContext {
+    constructor(options) {
+        this._model = options.model;
+    }
+    get name() {
+        return this._model.name;
+    }
+    get messages() {
+        return [...this._model.messages];
+    }
+}

package/lib/types.d.ts

@@ -8,6 +8,10 @@ export interface IUser {
     initials?: string;
     color?: string;
     avatar_url?: string;
+    /**
+     * The string to use to mention a user in the chat.
+     */
+    mention_name?: string;
 }
 /**
  * The configuration interface.
@@ -44,6 +48,7 @@ export interface IChatMessage<T = IUser, U = IAttachment> {
     time: number;
     sender: T;
     attachments?: U[];
+    mentions?: T[];
     raw_time?: boolean;
     deleted?: boolean;
     edited?: boolean;

package/lib/utils.d.ts

@@ -1,6 +1,7 @@
 import { CodeMirrorEditor } from '@jupyterlab/codemirror';
 import { Notebook } from '@jupyterlab/notebook';
 import { Widget } from '@lumino/widgets';
+import { IUser } from './types';
 /**
  * Gets the editor instance used by a document widget. Returns `null` if unable.
  */
@@ -9,3 +10,17 @@ export declare function getEditor(widget: Widget | null): CodeMirrorEditor | nul
  * Gets the index of the cell associated with `cellId`.
  */
 export declare function getCellIndex(notebook: Notebook, cellId: string): number;
+/**
+ * Replace a mention to user (@someone) to a span, for markdown renderer.
+ *
+ * @param content - the content to update.
+ * @param user - the user mentioned.
+ */
+export declare function replaceMentionToSpan(content: string, user: IUser): string;
+/**
+ * Replace a span to a mentioned to user string (@someone).
+ *
+ * @param content - the content to update.
+ * @param user - the user mentioned.
+ */
+export declare function replaceSpanToMention(content: string, user: IUser): string;