@jupyter/docprovider 4.2.0-beta.0 → 4.2.1

package/lib/TimelineSlider.d.ts

@@ -1,12 +1,14 @@
 import { ReactWidget } from '@jupyterlab/apputils';
 import { IForkProvider } from './ydrive';
+import { ServerConnection } from '@jupyterlab/services';
 export declare class TimelineWidget extends ReactWidget {
     private apiURL;
     private provider;
     private contentType;
     private format;
     private documentTimelineUrl;
-    constructor(apiURL: string, provider: IForkProvider, contentType: string, format: string, documentTimelineUrl: string);
+    private _serverSettings?;
+    constructor(apiURL: string, provider: IForkProvider, contentType: string, format: string, documentTimelineUrl: string, serverSettings?: ServerConnection.ISettings);
     render(): JSX.Element;
     updateContent(apiURL: string, provider: IForkProvider): void;
 }

package/lib/TimelineSlider.js

@@ -6,17 +6,18 @@ import { ReactWidget } from '@jupyterlab/apputils';
 import { TimelineSliderComponent } from './component';
 import * as React from 'react';
 export class TimelineWidget extends ReactWidget {
-    constructor(apiURL, provider, contentType, format, documentTimelineUrl) {
+    constructor(apiURL, provider, contentType, format, documentTimelineUrl, serverSettings) {
         super();
         this.apiURL = apiURL;
         this.provider = provider;
         this.contentType = contentType;
         this.format = format;
         this.documentTimelineUrl = documentTimelineUrl;
+        this._serverSettings = serverSettings;
         this.addClass('jp-timelineSliderWrapper');
     }
     render() {
-        return (React.createElement(TimelineSliderComponent, { key: this.apiURL, apiURL: this.apiURL, provider: this.provider, contentType: this.contentType, format: this.format, documentTimelineUrl: this.documentTimelineUrl }));
+        return (React.createElement(TimelineSliderComponent, { key: this.apiURL, apiURL: this.apiURL, provider: this.provider, contentType: this.contentType, format: this.format, documentTimelineUrl: this.documentTimelineUrl, serverSettings: this._serverSettings }));
     }
     updateContent(apiURL, provider) {
         this.apiURL = apiURL;

package/lib/component.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import '../style/slider.css';
 import { IForkProvider } from './ydrive';
+import { ServerConnection } from '@jupyterlab/services';
 type Props = {
     apiURL: string;
     provider: IForkProvider;
     contentType: string;
     format: string;
     documentTimelineUrl: string;
+    serverSettings?: ServerConnection.ISettings;
 };
 export declare const TimelineSliderComponent: React.FC<Props>;
 export {};

package/lib/component.js

@@ -7,7 +7,7 @@ import '../style/slider.css';
 import { requestUndoRedo, requestDocSession, requestDocumentTimeline } from './requests';
 import { historyIcon } from '@jupyterlab/ui-components';
 import { Notification } from '@jupyterlab/apputils';
-export const TimelineSliderComponent = ({ apiURL, provider, contentType, format, documentTimelineUrl }) => {
+export const TimelineSliderComponent = ({ apiURL, provider, contentType, format, documentTimelineUrl, serverSettings }) => {
     const [data, setData] = useState({
         roomId: '',
         timestamps: [],
@@ -23,7 +23,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
     async function fetchTimeline(notebookPath) {
         try {
             if (isFirstChange.current) {
-                const response = await requestDocumentTimeline(format, contentType, notebookPath);
+                const response = await requestDocumentTimeline(format, contentType, notebookPath, serverSettings);
                 if (!response.ok) {
                     if (response.status === 404) {
                         throw new Error('Not found');
@@ -43,7 +43,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
                     setData(data);
                     setCurrentTimestampIndex(data.timestamps.length - 1);
                     provider.connectToForkDoc(data.forkRoom, data.sessionId);
-                    sessionRef.current = await requestDocSession(format, contentType, extractFilenameFromURL(apiURL));
+                    sessionRef.current = await requestDocSession(format, contentType, extractFilenameFromURL(apiURL), serverSettings);
                 }
                 setToggle(true);
                 isFirstChange.current = false;
@@ -59,7 +59,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
             console.error('Session is not initialized');
             return;
         }
-        const response = await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, 'restore', 0, data.forkRoom);
+        const response = await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, 'restore', 0, data.forkRoom, serverSettings);
         if (response.code === 200) {
             Notification.success(response.status, { autoClose: 4000 });
             provider.reconnect();
@@ -84,7 +84,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
                 console.error('Session is not initialized');
                 return;
             }
-            await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, action, steps, data.forkRoom);
+            await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, action, steps, data.forkRoom, serverSettings);
         }
         catch (error) {
             console.error('Error fetching or applying updates:', error);

package/lib/forkManager.d.ts

@@ -1,5 +1,5 @@
 import { ICollaborativeContentProvider } from '@jupyter/collaborative-drive';
-import { Event } from '@jupyterlab/services';
+import { Event, ServerConnection } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
 import { IAllForksResponse, IForkChangedEvent, IForkCreationResponse, IForkManager } from './tokens';
 import { IForkProvider } from './ydrive';
@@ -32,10 +32,12 @@ export declare class ForkManager implements IForkManager {
     private _eventManager;
     private _forkAddedSignal;
     private _forkDeletedSignal;
+    private _serverSettings?;
 }
 export declare namespace ForkManager {
     interface IOptions {
         contentProvider: ICollaborativeContentProvider;
         eventManager: Event.IManager;
+        serverSettings?: ServerConnection.ISettings;
     }
 }

package/lib/forkManager.js

@@ -15,6 +15,7 @@ export class ForkManager {
         this._contentProvider = contentProvider;
         this._eventManager = eventManager;
         this._eventManager.stream.connect(this._handleEvent, this);
+        this._serverSettings = options.serverSettings;
     }
     get isDisposed() {
         return this._disposed;
@@ -40,13 +41,13 @@ export class ForkManager {
             body: JSON.stringify({ title, description, synchronize })
         };
         const url = URLExt.join(ROOM_FORK_URL, rootId);
-        const response = await requestAPI(url, init);
+        const response = await requestAPI(url, init, this._serverSettings);
         return response;
     }
     async getAllForks(rootId) {
         const url = URLExt.join(ROOM_FORK_URL, rootId);
         const init = { method: 'GET' };
-        const response = await requestAPI(url, init);
+        const response = await requestAPI(url, init, this._serverSettings);
         return response;
     }
     async deleteFork(options) {
@@ -54,7 +55,7 @@ export class ForkManager {
         const url = URLExt.join(ROOM_FORK_URL, forkId);
         const query = URLExt.objectToQueryString({ merge });
         const init = { method: 'DELETE' };
-        await requestAPI(`${url}${query}`, init);
+        await requestAPI(`${url}${query}`, init, this._serverSettings);
     }
     getProvider(options) {
         const { documentPath, format, type } = options;

package/lib/requests.d.ts

@@ -1,4 +1,4 @@
-import { Contents } from '@jupyterlab/services';
+import { ServerConnection, Contents } from '@jupyterlab/services';
 export declare const ROOM_FORK_URL = "api/collaboration/fork";
 /**
  * Document session model
@@ -28,7 +28,7 @@ export interface ISessionModel {
  * @param init Initial values for the request
  * @returns The response body interpreted as JSON
  */
-export declare function requestAPI<T = any>(endPoint?: string, init?: RequestInit): Promise<T>;
-export declare function requestDocSession(format: string, type: string, path: string): Promise<ISessionModel>;
-export declare function requestDocumentTimeline(format: string, type: string, path: string): Promise<any>;
-export declare function requestUndoRedo(roomid: string, action: 'undo' | 'redo' | 'restore', steps: number, forkRoom: string): Promise<any>;
+export declare function requestAPI<T = any>(endPoint?: string, init?: RequestInit, serverSettings?: ServerConnection.ISettings): Promise<T>;
+export declare function requestDocSession(format: string, type: string, path: string, serverSettings?: ServerConnection.ISettings): Promise<ISessionModel>;
+export declare function requestDocumentTimeline(format: string, type: string, path: string, serverSettings?: ServerConnection.ISettings): Promise<any>;
+export declare function requestUndoRedo(roomid: string, action: 'undo' | 'redo' | 'restore', steps: number, forkRoom: string, serverSettings?: ServerConnection.ISettings): Promise<any>;

package/lib/requests.js

@@ -19,9 +19,9 @@ export const ROOM_FORK_URL = 'api/collaboration/fork';
  * @param init Initial values for the request
  * @returns The response body interpreted as JSON
  */
-export async function requestAPI(endPoint = '', init = {}) {
+export async function requestAPI(endPoint = '', init = {}, serverSettings) {
     // Make request to Jupyter API
-    const settings = ServerConnection.makeSettings();
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     const requestUrl = URLExt.join(settings.baseUrl, endPoint);
     let response;
     try {
@@ -44,8 +44,8 @@ export async function requestAPI(endPoint = '', init = {}) {
     }
     return data;
 }
-export async function requestDocSession(format, type, path) {
-    const settings = ServerConnection.makeSettings();
+export async function requestDocSession(format, type, path, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     const url = URLExt.join(settings.baseUrl, DOC_SESSION_URL, encodeURIComponent(path));
     const body = {
         method: 'PUT',
@@ -72,8 +72,8 @@ export async function requestDocSession(format, type, path) {
     }
     return data;
 }
-export async function requestDocumentTimeline(format, type, path) {
-    const settings = ServerConnection.makeSettings();
+export async function requestDocumentTimeline(format, type, path, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     let url = URLExt.join(settings.baseUrl, TIMELINE_URL, path);
     url = url.concat(`?format=${format}&&type=${type}`);
     const body = {
@@ -88,8 +88,8 @@ export async function requestDocumentTimeline(format, type, path) {
     }
     return response;
 }
-export async function requestUndoRedo(roomid, action, steps, forkRoom) {
-    const settings = ServerConnection.makeSettings();
+export async function requestUndoRedo(roomid, action, steps, forkRoom, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     let url = URLExt.join(settings.baseUrl, DOC_FORK_URL, encodeURIComponent(roomid));
     url = url.concat(`?action=${action}&&steps=${steps}&&forkRoom=${forkRoom}`);
     const body = { method: 'PUT' };

package/lib/ydrive.js

@@ -1,6 +1,6 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+import { PageConfig } from '@jupyterlab/coreutils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import { WebSocketProvider } from './yprovider';
@@ -8,10 +8,6 @@ import * as decoding from 'lib0/decoding';
 import * as encoding from 'lib0/encoding';
 const DISABLE_RTC = PageConfig.getOption('disableRTC') === 'true' ? true : false;
 const RAW_MESSAGE_TYPE = 2;
-/**
- * The url for the default drive service.
- */
-const DOCUMENT_PROVIDER_URL = 'api/collaboration/room';
 export class RtcContentProvider {
     constructor(options) {
         this._onCreate = (options, sharedModel) => {
@@ -30,13 +26,13 @@ export class RtcContentProvider {
             });
             try {
                 const provider = new WebSocketProvider({
-                    url: URLExt.join(this._serverSettings.wsUrl, DOCUMENT_PROVIDER_URL),
                     path: options.path,
                     format: options.format,
                     contentType: options.contentType,
                     model: sharedModel,
                     user: this._user,
-                    translator: this._trans
+                    translator: this._trans,
+                    serverSettings: this._serverSettings
                 });
                 // Add the document path in the list of opened ones for this user.
                 const state = ((_e = this._globalAwareness) === null || _e === void 0 ? void 0 : _e.getLocalState()) || {};

package/lib/yprovider.d.ts

@@ -1,5 +1,5 @@
 import { IDocumentProvider } from '@jupyter/collaborative-drive';
-import { User } from '@jupyterlab/services';
+import { ServerConnection, User } from '@jupyterlab/services';
 import { TranslationBundle } from '@jupyterlab/translation';
 import { DocumentChange, YDocument } from '@jupyter/ydoc';
 import { WebsocketProvider as YWebsocketProvider } from 'y-websocket';
@@ -32,6 +32,7 @@ export declare class WebSocketProvider implements IDocumentProvider, IForkProvid
      */
     dispose(): void;
     reconnect(): Promise<void>;
+    private get _serverUrl();
     private _connect;
     connectToForkDoc(forkRoomId: string, sessionId: string): Promise<void>;
     get wsProvider(): YWebsocketProvider | null;
@@ -45,9 +46,10 @@ export declare class WebSocketProvider implements IDocumentProvider, IForkProvid
     private _isDisposed;
     private _path;
     private _ready;
-    private _serverUrl;
+    private _customServerUrl?;
     private _sharedModel;
     private _yWebsocketProvider;
+    private _serverSettings;
     private _trans;
 }
 /**
@@ -61,7 +63,7 @@ export declare namespace WebSocketProvider {
         /**
          * The server URL
          */
-        url: string;
+        url?: string;
         /**
          * The document file path
          */
@@ -86,5 +88,9 @@ export declare namespace WebSocketProvider {
          * The jupyterlab translator
          */
         translator: TranslationBundle;
+        /**
+         * The server settings.
+         */
+        serverSettings?: ServerConnection.ISettings;
     }
 }

package/lib/yprovider.js

@@ -3,10 +3,16 @@
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 import { showErrorMessage, Dialog } from '@jupyterlab/apputils';
+import { ServerConnection } from '@jupyterlab/services';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import { WebsocketProvider as YWebsocketProvider } from 'y-websocket';
 import { requestDocSession } from './requests';
+import { URLExt } from '@jupyterlab/coreutils';
+/**
+ * The url for the default drive service.
+ */
+const DOCUMENT_PROVIDER_URL = 'api/collaboration/room';
 /**
  * A class to provide Yjs synchronization over WebSocket.
  *
@@ -20,6 +26,7 @@ export class WebSocketProvider {
      * @param options The instantiation options for a WebSocketProvider
      */
     constructor(options) {
+        var _a;
         this._onConnectionClosed = (event) => {
             if (event.code === 1003) {
                 console.error('Document provider closed:', event.reason);
@@ -46,10 +53,12 @@ export class WebSocketProvider {
         this._path = options.path;
         this._contentType = options.contentType;
         this._format = options.format;
-        this._serverUrl = options.url;
+        this._customServerUrl = options.url;
         this._sharedModel = options.model;
         this._awareness = options.model.awareness;
         this._yWebsocketProvider = null;
+        this._serverSettings =
+            (_a = options.serverSettings) !== null && _a !== void 0 ? _a : ServerConnection.makeSettings();
         this._trans = options.translator;
         const user = options.user;
         user.ready
@@ -97,22 +106,38 @@ export class WebSocketProvider {
         this._disconnect();
         this._connect();
     }
+    get _serverUrl() {
+        var _a;
+        return ((_a = this._customServerUrl) !== null && _a !== void 0 ? _a : URLExt.join(this._serverSettings.wsUrl, DOCUMENT_PROVIDER_URL));
+    }
     async _connect() {
-        const session = await requestDocSession(this._format, this._contentType, this._path);
+        const session = await requestDocSession(this._format, this._contentType, this._path, this._serverSettings);
+        const token = this._serverSettings.token;
+        const params = { sessionId: session.sessionId };
+        if (this._serverSettings.appendToken && token !== '') {
+            params['token'] = token;
+        }
         this._yWebsocketProvider = new YWebsocketProvider(this._serverUrl, `${session.format}:${session.type}:${session.fileId}`, this._sharedModel.ydoc, {
             disableBc: true,
-            params: { sessionId: session.sessionId },
-            awareness: this._awareness
+            params,
+            awareness: this._awareness,
+            WebSocketPolyfill: this._serverSettings.WebSocket
         });
         this._yWebsocketProvider.on('sync', this._onSync);
         this._yWebsocketProvider.on('connection-close', this._onConnectionClosed);
     }
     async connectToForkDoc(forkRoomId, sessionId) {
+        const token = this._serverSettings.token;
+        const params = { sessionId };
+        if (this._serverSettings.appendToken && token !== '') {
+            params['token'] = token;
+        }
         this._disconnect();
         this._yWebsocketProvider = new YWebsocketProvider(this._serverUrl, forkRoomId, this._sharedModel.ydoc, {
             disableBc: true,
-            params: { sessionId },
-            awareness: this._awareness
+            params,
+            awareness: this._awareness,
+            WebSocketPolyfill: this._serverSettings.WebSocket
         });
     }
     get wsProvider() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyter/docprovider",
-  "version": "4.2.0-beta.0",
+  "version": "4.2.1",
   "description": "JupyterLab - Document Provider",
   "homepage": "https://github.com/jupyterlab/jupyter-collaboration",
   "bugs": {
@@ -41,7 +41,7 @@
     "watch": "tsc -b --watch"
   },
   "dependencies": {
-    "@jupyter/collaborative-drive": "^4.2.0-beta.0",
+    "@jupyter/collaborative-drive": "^4.2.1",
     "@jupyter/ydoc": "^2.1.3 || ^3.0.0",
     "@jupyterlab/apputils": "^4.5.0",
     "@jupyterlab/cells": "^4.5.0",