jupyterlab-chat 0.6.0

package/lib/__tests__/jupyterlab_collaborative_chat.spec.js

@@ -0,0 +1,13 @@
+"use strict";
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Example of [Jest](https://jestjs.io/docs/getting-started) unit tests
+ */
+describe('jupyterlab-chat', () => {
+    it('should be tested', () => {
+        expect(1 + 1).toEqual(2);
+    });
+});

package/lib/factory.d.ts

@@ -0,0 +1,118 @@
+import { IAutocompletionRegistry } from '@jupyter/chat';
+import { IThemeManager } from '@jupyterlab/apputils';
+import { ABCWidgetFactory, DocumentRegistry } from '@jupyterlab/docregistry';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { Contents } from '@jupyterlab/services';
+import { ISignal } from '@lumino/signaling';
+import { LabChatModel } from './model';
+import { LabChatPanel } from './widget';
+import { YChat } from './ychat';
+import { ILabChatConfig, IWidgetConfig } from './token';
+/**
+ * The object provided by the chatDocument extension.
+ * It is used to set the current config (from settings) to newly created chat widget,
+ * and to propagate every changes to the existing chat widgets.
+ */
+export declare class WidgetConfig implements IWidgetConfig {
+    /**
+     * The constructor of the WidgetConfig.
+     */
+    constructor(config: Partial<ILabChatConfig>);
+    /**
+     * Getter and setter for the config.
+     */
+    get config(): Partial<ILabChatConfig>;
+    set config(value: Partial<ILabChatConfig>);
+    /**
+     * Getter for the configChanged signal
+     */
+    get configChanged(): ISignal<WidgetConfig, Partial<ILabChatConfig>>;
+    private _config;
+    private _configChanged;
+}
+/**
+ * A widget factory to create new instances of LabChatWidget.
+ */
+export declare class ChatWidgetFactory extends ABCWidgetFactory<LabChatPanel, LabChatModel> {
+    /**
+     * Constructor of ChatWidgetFactory.
+     *
+     * @param options Constructor options
+     */
+    constructor(options: ChatWidgetFactory.IOptions<LabChatPanel>);
+    /**
+     * Create a new widget given a context.
+     *
+     * @param context Contains the information of the file
+     * @returns The widget
+     */
+    protected createNewWidget(context: ChatWidgetFactory.IContext): LabChatPanel;
+    private _themeManager;
+    private _rmRegistry;
+    private _autocompletionRegistry?;
+}
+export declare namespace ChatWidgetFactory {
+    interface IContext extends DocumentRegistry.IContext<LabChatModel> {
+        themeManager: IThemeManager | null;
+        rmRegistry: IRenderMimeRegistry;
+        autocompletionRegistry?: IAutocompletionRegistry;
+    }
+    interface IOptions<T extends LabChatPanel> extends DocumentRegistry.IWidgetFactoryOptions<T> {
+        themeManager: IThemeManager | null;
+        rmRegistry: IRenderMimeRegistry;
+        autocompletionRegistry?: IAutocompletionRegistry;
+    }
+}
+export declare class LabChatModelFactory implements DocumentRegistry.IModelFactory<LabChatModel> {
+    constructor(options: LabChatModel.IOptions);
+    collaborative: boolean;
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name(): string;
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType(): Contents.ContentType;
+    /**
+     * The format of the file.
+     *
+     * @returns the file format
+     */
+    get fileFormat(): Contents.FileFormat;
+    /**
+     * Get whether the model factory has been disposed.
+     *
+     * @returns disposed status
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose the model factory.
+     */
+    dispose(): void;
+    /**
+     * Get the preferred language given the path on the file.
+     *
+     * @param path path of the file represented by this document model
+     * @returns The preferred language
+     */
+    preferredLanguage(path: string): string;
+    /**
+     * Create a new instance of LabChatModel.
+     *
+     * @param languagePreference Language
+     * @param modelDB Model database
+     * @returns The model
+     */
+    createNew(options: DocumentRegistry.IModelOptions<YChat>): LabChatModel;
+    private _disposed;
+    private _user;
+    private _widgetConfig;
+    private _commands?;
+    private _activeCellManager;
+    private _selectionWatcher;
+}

package/lib/factory.js

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { ChatWidget } from '@jupyter/chat';
+import { ABCWidgetFactory } from '@jupyterlab/docregistry';
+import { Signal } from '@lumino/signaling';
+import { LabChatModel } from './model';
+import { LabChatPanel } from './widget';
+/**
+ * The object provided by the chatDocument extension.
+ * It is used to set the current config (from settings) to newly created chat widget,
+ * and to propagate every changes to the existing chat widgets.
+ */
+export class WidgetConfig {
+    /**
+     * The constructor of the WidgetConfig.
+     */
+    constructor(config) {
+        this._configChanged = new Signal(this);
+        this._config = config;
+    }
+    /**
+     * Getter and setter for the config.
+     */
+    get config() {
+        return this._config;
+    }
+    set config(value) {
+        this._config = { ...this._config, ...value };
+        this._configChanged.emit(value);
+    }
+    /**
+     * Getter for the configChanged signal
+     */
+    get configChanged() {
+        return this._configChanged;
+    }
+}
+/**
+ * A widget factory to create new instances of LabChatWidget.
+ */
+export class ChatWidgetFactory extends ABCWidgetFactory {
+    /**
+     * Constructor of ChatWidgetFactory.
+     *
+     * @param options Constructor options
+     */
+    constructor(options) {
+        super(options);
+        this._themeManager = options.themeManager;
+        this._rmRegistry = options.rmRegistry;
+        this._autocompletionRegistry = options.autocompletionRegistry;
+    }
+    /**
+     * Create a new widget given a context.
+     *
+     * @param context Contains the information of the file
+     * @returns The widget
+     */
+    createNewWidget(context) {
+        context.rmRegistry = this._rmRegistry;
+        context.themeManager = this._themeManager;
+        context.autocompletionRegistry = this._autocompletionRegistry;
+        return new LabChatPanel({
+            context,
+            content: new ChatWidget(context)
+        });
+    }
+}
+export class LabChatModelFactory {
+    constructor(options) {
+        var _a, _b;
+        this.collaborative = true;
+        this._disposed = false;
+        this._user = options.user;
+        this._widgetConfig = options.widgetConfig;
+        this._commands = options.commands;
+        this._activeCellManager = (_a = options.activeCellManager) !== null && _a !== void 0 ? _a : null;
+        this._selectionWatcher = (_b = options.selectionWatcher) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name() {
+        return 'chat';
+    }
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType() {
+        return 'chat';
+    }
+    /**
+     * The format of the file.
+     *
+     * @returns the file format
+     */
+    get fileFormat() {
+        return 'text';
+    }
+    /**
+     * Get whether the model factory has been disposed.
+     *
+     * @returns disposed status
+     */
+    get isDisposed() {
+        return this._disposed;
+    }
+    /**
+     * Dispose the model factory.
+     */
+    dispose() {
+        this._disposed = true;
+    }
+    /**
+     * Get the preferred language given the path on the file.
+     *
+     * @param path path of the file represented by this document model
+     * @returns The preferred language
+     */
+    preferredLanguage(path) {
+        return '';
+    }
+    /**
+     * Create a new instance of LabChatModel.
+     *
+     * @param languagePreference Language
+     * @param modelDB Model database
+     * @returns The model
+     */
+    createNew(options) {
+        return new LabChatModel({
+            ...options,
+            user: this._user,
+            widgetConfig: this._widgetConfig,
+            commands: this._commands,
+            activeCellManager: this._activeCellManager,
+            selectionWatcher: this._selectionWatcher
+        });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './factory';
+export * from './model';
+export * from './token';
+export * from './widget';
+export * from './ychat';

package/lib/index.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './factory';
+export * from './model';
+export * from './token';
+export * from './widget';
+export * from './ychat';

package/lib/model.d.ts

@@ -0,0 +1,64 @@
+import { ChatModel, IChatMessage, INewMessage, IUser } from '@jupyter/chat';
+import { IChangedArgs } from '@jupyterlab/coreutils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { User } from '@jupyterlab/services';
+import { PartialJSONObject } from '@lumino/coreutils';
+import { ISignal } from '@lumino/signaling';
+import { IWidgetConfig } from './token';
+import { YChat } from './ychat';
+/**
+ * Chat model namespace.
+ */
+export declare namespace LabChatModel {
+    interface IOptions extends ChatModel.IOptions {
+        widgetConfig: IWidgetConfig;
+        user: User.IIdentity | null;
+        sharedModel?: YChat;
+        languagePreference?: string;
+    }
+}
+/**
+ * The chat model.
+ */
+export declare class LabChatModel extends ChatModel implements DocumentRegistry.IModel {
+    constructor(options: LabChatModel.IOptions);
+    readonly collaborative = true;
+    get user(): IUser;
+    get sharedModel(): YChat;
+    get contentChanged(): ISignal<this, void>;
+    get stateChanged(): ISignal<this, IChangedArgs<any, any, string>>;
+    get dirty(): boolean;
+    set dirty(value: boolean);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    get disposed(): ISignal<LabChatModel, void>;
+    dispose(): void;
+    toString(): string;
+    fromString(data: string): void;
+    toJSON(): PartialJSONObject;
+    fromJSON(data: PartialJSONObject): void;
+    sendMessage(message: INewMessage): Promise<boolean | void> | boolean | void;
+    updateMessage(id: string, updatedMessage: IChatMessage): Promise<boolean | void> | boolean | void;
+    deleteMessage(id: string): Promise<boolean | void> | boolean | void;
+    /**
+     * Function called by the input on key pressed.
+     */
+    inputChanged(input?: string): void;
+    /**
+     * Triggered when an awareness state changes.
+     * Used to populate the writers list.
+     */
+    onAwarenessChange: () => void;
+    private _resetWritingStatus;
+    private _onchange;
+    readonly defaultKernelName: string;
+    readonly defaultKernelLanguage: string;
+    private _sharedModel;
+    private _dirty;
+    private _readOnly;
+    private _disposed;
+    private _contentChanged;
+    private _stateChanged;
+    private _timeoutWriting;
+    private _user;
+}

package/lib/model.js

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { ChatModel } from '@jupyter/chat';
+import { UUID } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import { YChat } from './ychat';
+const WRITING_DELAY = 1000;
+/**
+ * The chat model.
+ */
+export class LabChatModel extends ChatModel {
+    constructor(options) {
+        super(options);
+        this.collaborative = true;
+        /**
+         * Triggered when an awareness state changes.
+         * Used to populate the writers list.
+         */
+        this.onAwarenessChange = () => {
+            const writers = [];
+            const states = this.sharedModel.awareness.getStates();
+            for (const stateID of states.keys()) {
+                const state = states.get(stateID);
+                if (!state || !state.user || state.user.username === this.user.username) {
+                    continue;
+                }
+                if (state.isWriting) {
+                    writers.push(state.user);
+                }
+            }
+            this.updateWriters(writers);
+        };
+        this._onchange = (_, changes) => {
+            if (changes.messageChanges) {
+                const msgDelta = changes.messageChanges;
+                let index = 0;
+                msgDelta.forEach(delta => {
+                    if (delta.retain) {
+                        index += delta.retain;
+                    }
+                    else if (delta.insert) {
+                        const messages = delta.insert.map(ymessage => {
+                            const msg = {
+                                ...ymessage,
+                                sender: this.sharedModel.getUser(ymessage.sender) || {
+                                    username: 'User undefined'
+                                }
+                            };
+                            return msg;
+                        });
+                        this.messagesInserted(index, messages);
+                        index += messages.length;
+                    }
+                    else if (delta.delete) {
+                        this.messagesDeleted(index, delta.delete);
+                    }
+                });
+            }
+            if (changes.metadataChanges) {
+                changes.metadataChanges.forEach(change => {
+                    // no need to search for update or add, if the new value contains ID, let's
+                    // update the model ID.
+                    if (change.key === 'id') {
+                        this.id = change.newValue;
+                    }
+                });
+            }
+        };
+        this.defaultKernelName = '';
+        this.defaultKernelLanguage = '';
+        this._dirty = false;
+        this._readOnly = false;
+        this._disposed = new Signal(this);
+        this._contentChanged = new Signal(this);
+        this._stateChanged = new Signal(this);
+        this._timeoutWriting = null;
+        this._user = options.user || { username: 'user undefined' };
+        const { widgetConfig, sharedModel } = options;
+        if (sharedModel) {
+            this._sharedModel = sharedModel;
+        }
+        else {
+            this._sharedModel = YChat.create();
+        }
+        this.id = this._sharedModel.id;
+        this.sharedModel.changed.connect(this._onchange, this);
+        this.config = widgetConfig.config;
+        widgetConfig.configChanged.connect((_, config) => {
+            this.config = config;
+        });
+        this.sharedModel.awareness.on('change', this.onAwarenessChange);
+    }
+    get user() {
+        return this._user;
+    }
+    get sharedModel() {
+        return this._sharedModel;
+    }
+    get contentChanged() {
+        return this._contentChanged;
+    }
+    get stateChanged() {
+        return this._stateChanged;
+    }
+    get dirty() {
+        return this._dirty;
+    }
+    set dirty(value) {
+        this._dirty = value;
+    }
+    get readOnly() {
+        return this._readOnly;
+    }
+    set readOnly(value) {
+        this._readOnly = value;
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+        super.dispose();
+        this._sharedModel.dispose();
+        this._disposed.emit();
+        Signal.clearData(this);
+    }
+    toString() {
+        return JSON.stringify({}, null, 2);
+    }
+    fromString(data) {
+        /** */
+    }
+    toJSON() {
+        return JSON.parse(this.toString());
+    }
+    fromJSON(data) {
+        // nothing to do
+    }
+    sendMessage(message) {
+        this._resetWritingStatus();
+        if (this._timeoutWriting !== null) {
+            window.clearTimeout(this._timeoutWriting);
+        }
+        const msg = {
+            type: 'msg',
+            id: UUID.uuid4(),
+            body: message.body,
+            time: Date.now() / 1000,
+            sender: this._user.username,
+            raw_time: true
+        };
+        // Add the user if it does not exist or has changed
+        if (!(this.sharedModel.getUser(this._user.username) === this._user)) {
+            this.sharedModel.setUser(this._user);
+        }
+        this.sharedModel.addMessage(msg);
+    }
+    updateMessage(id, updatedMessage) {
+        const index = this.sharedModel.getMessageIndex(id);
+        let message = this.sharedModel.getMessage(index);
+        if (message) {
+            message.body = updatedMessage.body;
+            message.edited = true;
+        }
+        else {
+            const sender = updatedMessage.sender.username;
+            message = {
+                type: 'msg',
+                id: id || UUID.uuid4(),
+                body: updatedMessage.body,
+                time: updatedMessage.time || Date.now() / 1000,
+                sender: sender,
+                edited: true
+            };
+        }
+        this.sharedModel.updateMessage(index, message);
+    }
+    deleteMessage(id) {
+        const index = this.sharedModel.getMessageIndex(id);
+        const message = this.sharedModel.getMessage(index);
+        if (!message) {
+            console.error('The message to delete does not exist');
+            return;
+        }
+        message.body = '';
+        message.deleted = true;
+        this.sharedModel.updateMessage(index, message);
+    }
+    /**
+     * Function called by the input on key pressed.
+     */
+    inputChanged(input) {
+        if (!input || !this.config.sendTypingNotification) {
+            return;
+        }
+        const awareness = this.sharedModel.awareness;
+        if (this._timeoutWriting !== null) {
+            window.clearTimeout(this._timeoutWriting);
+        }
+        awareness.setLocalStateField('isWriting', true);
+        this._timeoutWriting = window.setTimeout(() => {
+            this._resetWritingStatus();
+        }, WRITING_DELAY);
+    }
+    _resetWritingStatus() {
+        const awareness = this.sharedModel.awareness;
+        const states = awareness.getLocalState();
+        states === null || states === void 0 ? true : delete states.isWriting;
+        awareness.setLocalState(states);
+        this._timeoutWriting = null;
+    }
+}

package/lib/token.d.ts

@@ -0,0 +1,91 @@
+import { IConfig, IActiveCellManager, ISelectionWatcher } from '@jupyter/chat';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Token } from '@lumino/coreutils';
+import { ISignal } from '@lumino/signaling';
+import { ChatPanel, LabChatPanel } from './widget';
+/**
+ * The file type for a chat document.
+ */
+export declare const chatFileType: DocumentRegistry.IFileType;
+/**
+ * The token for the chat widget factory.
+ */
+export declare const IChatFactory: Token<IChatFactory>;
+/**
+ * The chat configs.
+ */
+export interface ILabChatConfig extends IConfig {
+    /**
+     * The default directory where to create and look for chat.
+     */
+    defaultDirectory?: string;
+}
+/**
+ * The interface for the chat factory objects.
+ */
+export interface IChatFactory {
+    /**
+     * The chat widget config.
+     */
+    widgetConfig: IWidgetConfig;
+    /**
+     * The chat panel tracker.
+     */
+    tracker: IWidgetTracker<LabChatPanel>;
+}
+/**
+ * The interface for the chats config.
+ */
+export interface IWidgetConfig {
+    /**
+     * The widget config
+     */
+    config: Partial<ILabChatConfig>;
+    /**
+     * A signal emitting when the configuration for the chats has changed.
+     */
+    configChanged: IConfigChanged;
+}
+/**
+ * A signal emitting when the configuration for the chats has changed.
+ */
+export interface IConfigChanged extends ISignal<IWidgetConfig, Partial<ILabChatConfig>> {
+}
+/**
+ * Command ids.
+ */
+export declare const CommandIDs: {
+    /**
+     * Create a chat file.
+     */
+    createChat: string;
+    /**
+     * Open a chat file.
+     */
+    openChat: string;
+    /**
+     * Move a main widget to the side panel.
+     */
+    moveToSide: string;
+    /**
+     * Mark as read.
+     */
+    markAsRead: string;
+    /**
+     * Focus the input of the current chat.
+     */
+    focusInput: string;
+};
+/**
+ * The chat panel token.
+ */
+export declare const IChatPanel: Token<ChatPanel>;
+/**
+ * The active cell manager plugin.
+ */
+export declare const IActiveCellManagerToken: Token<IActiveCellManager>;
+/**
+ * The selection watcher plugin.
+ */
+export declare const ISelectionWatcherToken: Token<ISelectionWatcher>;