@fails-components/jupyter-filesystem-extension 0.0.1-alpha.8 → 0.0.2

package/lib/drive.d.ts

@@ -0,0 +1,50 @@
+import { Contents, Drive, ServerConnection } from '@jupyterlab/services';
+import { ISignal } from '@lumino/signaling';
+interface IContentEvent {
+    task: string;
+}
+export interface ILoadJupyterContentEvent extends IContentEvent {
+    task: 'loadFile';
+    fileData: object | undefined;
+    fileName: string;
+}
+export interface ISavedJupyterContentEvent extends IContentEvent {
+    task: 'savedFile';
+    fileName: string;
+}
+export type IContentEventType = ILoadJupyterContentEvent | ISavedJupyterContentEvent;
+type IModel = Contents.IModel;
+export declare class FailsDrive implements Contents.IDrive {
+    constructor(options: Drive.IOptions);
+    dispose(): void;
+    get isDisposed(): boolean;
+    get name(): string;
+    get serverSettings(): ServerConnection.ISettings;
+    get fileChanged(): ISignal<Contents.IDrive, Contents.IChangedArgs>;
+    getDownloadUrl(path: string): Promise<string>;
+    onMessage(event: IContentEventType): Promise<any>;
+    get(path: string, options?: Contents.IFetchOptions): Promise<IModel>;
+    save(path: string, options?: Partial<Contents.IModel>): Promise<Contents.IModel>;
+    newUntitled(options?: Contents.ICreateOptions): Promise<IModel>;
+    rename(oldLocalPath: string, newLocalPath: string): Promise<IModel>;
+    delete(path: string): Promise<void>;
+    copy(path: string, toDir: string): Promise<IModel>;
+    createCheckpoint(path: string): Promise<Contents.ICheckpointModel>;
+    listCheckpoints(path: string): Promise<Contents.ICheckpointModel[]>;
+    restoreCheckpoint(path: string, checkpointID: string): Promise<void>;
+    deleteCheckpoint(path: string, checkpointID: string): Promise<void>;
+    static EMPTY_NB: {
+        metadata: {
+            orig_nbformat: number;
+        };
+        nbformat_minor: number;
+        nbformat: number;
+        cells: never[];
+    };
+    private _fileContent;
+    private _isDisposed;
+    private _fileChanged;
+    private _fileName;
+    private _serverSettings;
+}
+export {};

package/lib/{contents.js → drive.js}

@@ -1,21 +1,44 @@
-import { PromiseDelegate } from '@lumino/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+import { Signal } from '@lumino/signaling';
 // portions used from Jupyterlab:
 /* -----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 // This code contains portions from or is inspired by Jupyter lab and lite
+// especially the Drive implementation
 const jsonMime = 'application/json';
-class FailsContents {
-    constructor() {
-        this._fileContent = JSON.stringify(FailsContents.EMPTY_NB);
+class FailsDrive {
+    constructor(options) {
+        var _a;
+        this._fileContent = JSON.stringify(FailsDrive.EMPTY_NB);
+        this._isDisposed = false;
+        this._fileChanged = new Signal(this);
         this._fileName = 'unloaded.ipynb';
-        this._ready = new PromiseDelegate();
-        if (!window.failsCallbacks) {
-            window.failsCallbacks = {};
+        this._serverSettings =
+            (_a = options.serverSettings) !== null && _a !== void 0 ? _a : ServerConnection.makeSettings();
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
         }
-        this._failsCallbacks = window.failsCallbacks;
-        this._failsCallbacks.callContents = this.onMessage.bind(this);
+        this._isDisposed = true;
+        Signal.clearData(this);
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    get name() {
+        return 'JupyterFailsSingleFileDrive';
+    }
+    get serverSettings() {
+        return this._serverSettings;
+    }
+    get fileChanged() {
+        return this._fileChanged;
+    }
+    async getDownloadUrl(path) {
+        throw new Error('Method not implemented.');
     }
     async onMessage(event) {
         // todo handle events
@@ -23,8 +46,24 @@ class FailsContents {
             case 'loadFile':
                 {
                     const loadevent = event;
-                    this._fileContent = JSON.stringify(loadevent.fileData || FailsContents.EMPTY_NB);
+                    this._fileContent = JSON.stringify(loadevent.fileData || FailsDrive.EMPTY_NB);
                     this._fileName = loadevent.fileName;
+                    this._fileChanged.emit({
+                        type: 'save',
+                        oldValue: null,
+                        newValue: {
+                            name: this._fileName,
+                            path: this._fileName,
+                            last_modified: new Date(0).toISOString(),
+                            created: new Date(0).toISOString(),
+                            format: 'json',
+                            mimetype: jsonMime,
+                            content: JSON.parse(this._fileContent),
+                            size: 0,
+                            writable: true,
+                            type: 'notebook'
+                        }
+                    });
                 }
                 break;
             case 'savedFile':
@@ -40,12 +79,6 @@ class FailsContents {
                 break;
         }
     }
-    get ready() {
-        return this._ready.promise;
-    }
-    async initialize() {
-        this._ready.resolve(void 0);
-    }
     async get(path, options) {
         // remove leading slash
         path = decodeURIComponent(path.replace(/^\//, ''));
@@ -79,13 +112,13 @@ class FailsContents {
         if (path === this._fileName) {
             return serverFile;
         }
-        return null; // not found
+        throw Error(`Could not find content with path ${path}`);
     }
     async save(path, options = {}) {
         path = decodeURIComponent(path);
         if (path !== this._fileName) {
             // we only allow the proxy object
-            return null;
+            throw Error(`File ${path} is not the proxy file`);
         }
         const chunk = options.chunk;
         const chunked = chunk ? chunk > 1 || chunk === -1 : false;
@@ -93,7 +126,7 @@ class FailsContents {
             content: chunked
         });
         if (!item) {
-            return null;
+            throw Error(`Could not find file with path ${path}`);
         }
         const modified = new Date().toISOString();
         // override with the new values
@@ -122,9 +155,19 @@ class FailsContents {
                 size: newcontent.length
             };
             this._fileContent = JSON.stringify(newcontent); // no parsing
+            this._fileChanged.emit({
+                type: 'save',
+                oldValue: null,
+                newValue: item
+            });
             return item;
         }
         this._fileContent = JSON.stringify(item.content); // no parsing
+        this._fileChanged.emit({
+            type: 'save',
+            oldValue: null,
+            newValue: item
+        });
         return item;
     }
     // For fails creating a new file is not allowed, so no need to implment it
@@ -154,7 +197,7 @@ class FailsContents {
         throw new Error('deleteCheckpoint not (yet?) implemented');
     }
 }
-FailsContents.EMPTY_NB = {
+FailsDrive.EMPTY_NB = {
     metadata: {
         orig_nbformat: 4
     },
@@ -162,4 +205,4 @@ FailsContents.EMPTY_NB = {
     nbformat: 4,
     cells: []
 };
-export { FailsContents };
+export { FailsDrive };

package/lib/index.d.ts

@@ -1,5 +1,4 @@
-import { IContents } from '@jupyterlite/contents';
-import { JupyterLiteServerPlugin } from '@jupyterlite/server';
-export declare const failsContentsPlugin: JupyterLiteServerPlugin<IContents>;
-declare const plugins: JupyterLiteServerPlugin<any>[];
+import { ServiceManagerPlugin } from '@jupyterlab/services';
+export * from './token';
+declare const plugins: ServiceManagerPlugin<any>[];
 export default plugins;

package/lib/index.js

@@ -1,37 +1,60 @@
-import { IContents } from '@jupyterlite/contents';
-import { ISettings } from '@jupyterlite/settings';
-import { FailsContents } from './contents';
+import { IDefaultDrive, ISettingManager, IServerSettings } from '@jupyterlab/services';
+import { FailsDrive } from './drive';
 import { FailsSettings } from './settings';
-export const failsContentsPlugin = {
-    id: '@fails-components/jupyter-fails-server:contents',
+import { IFailsDriveMessages } from './token';
+export * from './token';
+const failsDriveMessages = {
+    id: '@fails-components/jupyter-applet-widget:drivemessages',
     requires: [],
     autoStart: true,
-    provides: IContents,
-    activate: (app) => {
-        if (app.namespace !== 'JupyterLite Server') {
-            console.log('Not on server');
-        }
-        const contents = new FailsContents();
-        app.started.then(() => contents.initialize().catch(console.warn));
-        return contents;
+    provides: IFailsDriveMessages,
+    activate: (_) => {
+        let initialWaitRes;
+        const initialWait = new Promise(resolve => (initialWaitRes = resolve));
+        let messageHandler;
+        const driveMessages = {
+            registerMessageHandler: (handler) => {
+                messageHandler = handler;
+                if (initialWaitRes) {
+                    initialWaitRes(undefined);
+                }
+                initialWaitRes = undefined;
+            },
+            sendMessage: async (msg) => {
+                await initialWait;
+                return messageHandler(msg);
+            }
+        };
+        return driveMessages;
+    }
+};
+const failsDrivePlugin = {
+    id: '@fails-components/jupyter-applet-widget:drive',
+    requires: [IFailsDriveMessages],
+    autoStart: true,
+    provides: IDefaultDrive,
+    activate: (_, driveMessages) => {
+        const drive = new FailsDrive({});
+        driveMessages.registerMessageHandler(msg => drive.onMessage(msg));
+        return drive;
     }
 };
 const failsSettingsPlugin = {
-    id: '@fails-components/jupyter-fails-server:settings',
+    id: '@fails-components/jupyter-applet-widget:settings',
     requires: [],
     autoStart: true,
-    provides: ISettings,
-    activate: (app) => {
-        if (app.namespace !== 'JupyterLite Server') {
-            console.log('Not on server');
-        }
-        const settings = new FailsSettings();
-        app.started.then(() => settings.initialize().catch(console.warn));
+    provides: ISettingManager,
+    optional: [IServerSettings],
+    activate: (_, serverSettings) => {
+        const settings = new FailsSettings({
+            serverSettings: serverSettings !== null && serverSettings !== void 0 ? serverSettings : undefined
+        });
         return settings;
     }
 };
 const plugins = [
-    failsContentsPlugin,
+    failsDriveMessages,
+    failsDrivePlugin,
     failsSettingsPlugin
 ];
 export default plugins;

package/lib/settings.d.ts

@@ -1,15 +1,15 @@
-import { ISettings, IPlugin as ISettingsPlugin } from '@jupyterlite/settings';
-export declare class FailsSettings implements ISettings {
-    static _overrides: Record<string, ISettingsPlugin['schema']['default']>;
-    static override(plugin: ISettingsPlugin): ISettingsPlugin;
-    constructor();
-    get ready(): Promise<void>;
-    initialize(): Promise<void>;
-    get(pluginId: string): Promise<ISettingsPlugin | undefined>;
-    getAll(): Promise<{
-        settings: ISettingsPlugin[];
+import { Setting, SettingManager } from '@jupyterlab/services';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+export type SettingsFile = 'all.json' | 'all_federated.json';
+export declare class FailsSettings extends SettingManager implements Setting.IManager {
+    static _overrides: Record<string, ISettingRegistry.IPlugin['schema']['default']>;
+    static override(plugin: ISettingRegistry.IPlugin): ISettingRegistry.IPlugin;
+    constructor(options: SettingManager.IOptions);
+    fetch(pluginId: string): Promise<ISettingRegistry.IPlugin>;
+    list(query?: 'ids'): Promise<{
+        ids: string[];
+        values: ISettingRegistry.IPlugin[];
     }>;
     private _getAll;
-    save(pluginId: string, raw: string): Promise<void>;
-    private _ready;
+    save(id: string, raw: string): Promise<void>;
 }

package/lib/settings.js

@@ -1,13 +1,7 @@
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
-import { PromiseDelegate } from '@lumino/coreutils';
+import { SettingManager } from '@jupyterlab/services';
 import * as json5 from 'json5';
-// portions used from Jupyterlab:
-/* -----------------------------------------------------------------------------
-| Copyright (c) Jupyter Development Team.
-| Distributed under the terms of the Modified BSD License.
-|----------------------------------------------------------------------------*/
-// This code contains portions from or is inspired by Jupyter lab and lite
-class FailsSettings {
+class FailsSettings extends SettingManager {
     static override(plugin) {
         if (FailsSettings._overrides[plugin.id]) {
             if (!plugin.schema.properties) {
@@ -20,32 +14,32 @@ class FailsSettings {
         }
         return plugin;
     }
-    constructor() {
-        this._ready = new PromiseDelegate();
-    }
-    get ready() {
-        return this._ready.promise;
-    }
-    async initialize() {
-        this._ready.resolve(void 0);
+    constructor(options) {
+        super({
+            serverSettings: options.serverSettings
+        });
     }
-    // copied from the original settings
-    async get(pluginId) {
-        const all = await this.getAll();
-        const settings = all.settings;
+    // copied from the original settings (updated)
+    async fetch(pluginId) {
+        const all = await this.list();
+        const settings = all.values;
         const setting = settings.find((setting) => {
             return setting.id === pluginId;
         });
+        if (!setting) {
+            throw new Error(`Setting ${pluginId} not found`);
+        }
         return setting;
     }
-    // copied from the original settings
-    async getAll() {
+    // copied from the original settings (updated)
+    async list(query) {
+        var _a, _b;
         const allCore = await this._getAll('all.json');
         let allFederated = [];
         try {
             allFederated = await this._getAll('all_federated.json');
         }
-        catch (_a) {
+        catch (_c) {
             // handle the case where there is no federated extension
         }
         // JupyterLab 4 expects all settings to be returned in one go
@@ -61,7 +55,17 @@ class FailsSettings {
                 settings: json5.parse(raw)
             };
         }));
-        return { settings };
+        // format the settings
+        const ids = (_a = settings.map((plugin) => plugin.id)) !== null && _a !== void 0 ? _a : [];
+        let values = [];
+        if (!query) {
+            values =
+                (_b = settings.map((plugin) => {
+                    plugin.data = { composite: {}, user: {} };
+                    return plugin;
+                })) !== null && _b !== void 0 ? _b : [];
+        }
+        return { ids, values };
     }
     // one to one copy from settings of the original JupyterLite
     async _getAll(file) {
@@ -70,7 +74,7 @@ class FailsSettings {
         const all = (await (await fetch(URLExt.join(settingsUrl, file))).json());
         return all;
     }
-    async save(pluginId, raw) {
+    async save(id, raw) {
         // we do nothing
     }
 }

package/lib/token.d.ts

@@ -0,0 +1,8 @@
+import { Token } from '@lumino/coreutils';
+import { IContentEventType } from './drive';
+export type IFailsDriveMessageHandler = (msg: IContentEventType) => Promise<void> | void;
+export interface IFailsDriveMessages {
+    registerMessageHandler: (handler: IFailsDriveMessageHandler) => void;
+    sendMessage: (msg: IContentEventType) => Promise<any>;
+}
+export declare const IFailsDriveMessages: Token<IFailsDriveMessages>;

package/lib/token.js

@@ -0,0 +1,2 @@
+import { Token } from '@lumino/coreutils';
+export const IFailsDriveMessages = new Token('@fails-components/jupyter-fails:IFailsDriveMessages', 'A service to communicate to the FAILS single file drive.');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fails-components/jupyter-filesystem-extension",
-    "version": "0.0.1-alpha.8",
+    "version": "0.0.2",
     "description": "A collection of extensions, that redirect's filesystems access to fails and let fails puppeteer Jupyter lite. ",
     "keywords": [
         "jupyter",
@@ -60,15 +60,11 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@fails-components/jupyter-launcher": "^0.0.1-alpha.8",
-        "@jupyter-widgets/jupyterlab-manager": "^5.0.11",
-        "@jupyterlab/application": "^4.3.4",
-        "@jupyterlab/services": "^7.3.4",
-        "@jupyterlite/application-extension": "^0.5.0",
-        "@jupyterlite/contents": "^0.5.0",
-        "@jupyterlite/server": "^0.5.0",
-        "@jupyterlite/settings": "^0.5.0",
-        "@lumino/coreutils": "^2.2.0",
+        "@jupyterlab/coreutils": "^6.4.3",
+        "@jupyterlab/services": "^7.4.3",
+        "@jupyterlab/settingregistry": "^4.4.3",
+        "@lumino/coreutils": "^2.2.1",
+        "@lumino/signaling": "^2.1.4",
         "json5": "^2.2.3"
     },
     "devDependencies": {
@@ -111,9 +107,6 @@
         "outputDir": "fails_components_jupyter_filesystem_extension/labextension",
         "schemaDir": "schema"
     },
-    "jupyterlite": {
-        "liteExtension": true
-    },
     "eslintIgnore": [
         "node_modules",
         "dist",

package/src/{contents.ts → drive.ts}

@@ -1,12 +1,24 @@
-import { Contents as ServerContents } from '@jupyterlab/services';
-import { IContents } from '@jupyterlite/contents';
-import { PromiseDelegate } from '@lumino/coreutils';
-import {
-  IFailsCallbacks,
-  IContentEventType,
-  ILoadJupyterContentEvent,
-  ISavedJupyterContentEvent
-} from '@fails-components/jupyter-launcher';
+import { Contents, Drive, ServerConnection } from '@jupyterlab/services';
+import { ISignal, Signal } from '@lumino/signaling';
+
+interface IContentEvent {
+  task: string;
+}
+
+export interface ILoadJupyterContentEvent extends IContentEvent {
+  task: 'loadFile';
+  fileData: object | undefined;
+  fileName: string;
+}
+
+export interface ISavedJupyterContentEvent extends IContentEvent {
+  task: 'savedFile';
+  fileName: string;
+}
+
+export type IContentEventType =
+  | ILoadJupyterContentEvent
+  | ISavedJupyterContentEvent; // use union
 
 // portions used from Jupyterlab:
 /* -----------------------------------------------------------------------------
@@ -14,17 +26,43 @@ import {
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 // This code contains portions from or is inspired by Jupyter lab and lite
+// especially the Drive implementation
 
 const jsonMime = 'application/json';
+type IModel = Contents.IModel;
 
-export class FailsContents implements IContents {
-  constructor() {
-    this._ready = new PromiseDelegate();
-    if (!(window as any).failsCallbacks) {
-      (window as any).failsCallbacks = {};
+export class FailsDrive implements Contents.IDrive {
+  constructor(options: Drive.IOptions) {
+    this._serverSettings =
+      options.serverSettings ?? ServerConnection.makeSettings();
+  }
+
+  dispose(): void {
+    if (this.isDisposed) {
+      return;
     }
-    this._failsCallbacks = (window as any).failsCallbacks;
-    this._failsCallbacks.callContents = this.onMessage.bind(this);
+    this._isDisposed = true;
+    Signal.clearData(this);
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  get name(): string {
+    return 'JupyterFailsSingleFileDrive';
+  }
+
+  get serverSettings(): ServerConnection.ISettings {
+    return this._serverSettings;
+  }
+
+  get fileChanged(): ISignal<Contents.IDrive, Contents.IChangedArgs> {
+    return this._fileChanged;
+  }
+
+  async getDownloadUrl(path: string): Promise<string> {
+    throw new Error('Method not implemented.');
   }
 
   async onMessage(event: IContentEventType): Promise<any> {
@@ -34,9 +72,25 @@ export class FailsContents implements IContents {
         {
           const loadevent = event as ILoadJupyterContentEvent;
           this._fileContent = JSON.stringify(
-            loadevent.fileData || FailsContents.EMPTY_NB
+            loadevent.fileData || FailsDrive.EMPTY_NB
           );
           this._fileName = loadevent.fileName;
+          this._fileChanged.emit({
+            type: 'save',
+            oldValue: null,
+            newValue: {
+              name: this._fileName,
+              path: this._fileName,
+              last_modified: new Date(0).toISOString(),
+              created: new Date(0).toISOString(),
+              format: 'json' as Contents.FileFormat,
+              mimetype: jsonMime,
+              content: JSON.parse(this._fileContent),
+              size: 0,
+              writable: true,
+              type: 'notebook'
+            }
+          });
         }
         break;
       case 'savedFile':
@@ -53,18 +107,7 @@ export class FailsContents implements IContents {
     }
   }
 
-  get ready(): Promise<void> {
-    return this._ready.promise;
-  }
-
-  async initialize() {
-    this._ready.resolve(void 0);
-  }
-
-  async get(
-    path: string,
-    options?: ServerContents.IFetchOptions
-  ): Promise<ServerContents.IModel | null> {
+  async get(path: string, options?: Contents.IFetchOptions): Promise<IModel> {
     // remove leading slash
     path = decodeURIComponent(path.replace(/^\//, ''));
 
@@ -73,7 +116,7 @@ export class FailsContents implements IContents {
       path: this._fileName,
       last_modified: new Date(0).toISOString(),
       created: new Date(0).toISOString(),
-      format: 'json' as ServerContents.FileFormat,
+      format: 'json' as Contents.FileFormat,
       mimetype: jsonMime,
       content: JSON.parse(this._fileContent),
       size: 0,
@@ -99,27 +142,27 @@ export class FailsContents implements IContents {
     if (path === this._fileName) {
       return serverFile;
     }
-    return null; // not found
+    throw Error(`Could not find content with path ${path}`);
   }
 
   async save(
     path: string,
-    options: Partial<ServerContents.IModel> = {}
-  ): Promise<ServerContents.IModel | null> {
+    options: Partial<Contents.IModel> = {}
+  ): Promise<Contents.IModel> {
     path = decodeURIComponent(path);
     if (path !== this._fileName) {
       // we only allow the proxy object
-      return null;
+      throw Error(`File ${path} is not the proxy file`);
     }
     const chunk = options.chunk;
     const chunked = chunk ? chunk > 1 || chunk === -1 : false;
 
-    let item: ServerContents.IModel | null = await this.get(path, {
+    let item: Contents.IModel | null = await this.get(path, {
       content: chunked
     });
 
     if (!item) {
-      return null;
+      throw Error(`Could not find file with path ${path}`);
     }
 
     const modified = new Date().toISOString();
@@ -152,24 +195,29 @@ export class FailsContents implements IContents {
         size: newcontent.length
       };
       this._fileContent = JSON.stringify(newcontent); // no parsing
+      this._fileChanged.emit({
+        type: 'save',
+        oldValue: null,
+        newValue: item
+      });
       return item;
     }
 
     this._fileContent = JSON.stringify(item.content); // no parsing
+    this._fileChanged.emit({
+      type: 'save',
+      oldValue: null,
+      newValue: item
+    });
     return item;
   }
 
   // For fails creating a new file is not allowed, so no need to implment it
-  async newUntitled(
-    options?: ServerContents.ICreateOptions
-  ): Promise<ServerContents.IModel | null> {
+  async newUntitled(options?: Contents.ICreateOptions): Promise<IModel> {
     throw new Error('NewUntitled not implemented');
   }
 
-  async rename(
-    oldLocalPath: string,
-    newLocalPath: string
-  ): Promise<ServerContents.IModel> {
+  async rename(oldLocalPath: string, newLocalPath: string): Promise<IModel> {
     throw new Error('rename not implemented');
   }
 
@@ -177,19 +225,15 @@ export class FailsContents implements IContents {
     throw new Error('delete not implemented');
   }
 
-  async copy(path: string, toDir: string): Promise<ServerContents.IModel> {
+  async copy(path: string, toDir: string): Promise<IModel> {
     throw new Error('copy not implemented');
   }
 
-  async createCheckpoint(
-    path: string
-  ): Promise<ServerContents.ICheckpointModel> {
+  async createCheckpoint(path: string): Promise<Contents.ICheckpointModel> {
     throw new Error('createCheckpoint not (yet?) implemented');
   }
 
-  async listCheckpoints(
-    path: string
-  ): Promise<ServerContents.ICheckpointModel[]> {
+  async listCheckpoints(path: string): Promise<Contents.ICheckpointModel[]> {
     // throw new Error('listCheckpoints not (yet?) implemented');
     return [{ id: 'fakeCheckpoint', last_modified: new Date().toISOString() }];
   }
@@ -211,8 +255,11 @@ export class FailsContents implements IContents {
     cells: []
   };
 
-  private _ready: PromiseDelegate<void>;
-  private _fileContent: string = JSON.stringify(FailsContents.EMPTY_NB);
+  private _fileContent: string = JSON.stringify(FailsDrive.EMPTY_NB);
+  private _isDisposed = false;
+  private _fileChanged = new Signal<Contents.IDrive, Contents.IChangedArgs>(
+    this
+  );
   private _fileName: string = 'unloaded.ipynb';
-  private _failsCallbacks: IFailsCallbacks;
+  private _serverSettings: ServerConnection.ISettings;
 }

package/src/index.ts

@@ -1,44 +1,73 @@
-import { IContents } from '@jupyterlite/contents';
 import {
-  JupyterLiteServerPlugin,
-  JupyterLiteServer
-} from '@jupyterlite/server';
-import { ISettings } from '@jupyterlite/settings';
-import { FailsContents } from './contents';
+  IDefaultDrive,
+  Contents,
+  ServerConnection,
+  Setting,
+  ISettingManager,
+  IServerSettings,
+  ServiceManagerPlugin
+} from '@jupyterlab/services';
+import { FailsDrive, IContentEventType } from './drive';
 import { FailsSettings } from './settings';
+import { IFailsDriveMessageHandler, IFailsDriveMessages } from './token';
 
-export const failsContentsPlugin: JupyterLiteServerPlugin<IContents> = {
-  id: '@fails-components/jupyter-fails-server:contents',
+export * from './token';
+
+const failsDriveMessages: ServiceManagerPlugin<IFailsDriveMessages> = {
+  id: '@fails-components/jupyter-applet-widget:drivemessages',
   requires: [],
   autoStart: true,
-  provides: IContents,
-  activate: (app: JupyterLiteServer) => {
-    if (app.namespace !== 'JupyterLite Server') {
-      console.log('Not on server');
-    }
-    const contents = new FailsContents();
-    app.started.then(() => contents.initialize().catch(console.warn));
-    return contents;
+  provides: IFailsDriveMessages,
+  activate: (_: null) => {
+    let initialWaitRes: ((val: unknown) => void) | undefined;
+    const initialWait = new Promise(resolve => (initialWaitRes = resolve));
+    let messageHandler: IFailsDriveMessageHandler;
+    const driveMessages = {
+      registerMessageHandler: (handler: IFailsDriveMessageHandler) => {
+        messageHandler = handler;
+        if (initialWaitRes) {
+          initialWaitRes(undefined);
+        }
+        initialWaitRes = undefined;
+      },
+      sendMessage: async (msg: IContentEventType) => {
+        await initialWait;
+        return messageHandler(msg);
+      }
+    };
+    return driveMessages;
+  }
+};
+
+const failsDrivePlugin: ServiceManagerPlugin<Contents.IDrive> = {
+  id: '@fails-components/jupyter-applet-widget:drive',
+  requires: [IFailsDriveMessages],
+  autoStart: true,
+  provides: IDefaultDrive,
+  activate: (_: null, driveMessages: IFailsDriveMessages) => {
+    const drive = new FailsDrive({});
+    driveMessages.registerMessageHandler(msg => drive.onMessage(msg));
+    return drive;
   }
 };
 
-const failsSettingsPlugin: JupyterLiteServerPlugin<ISettings> = {
-  id: '@fails-components/jupyter-fails-server:settings',
+const failsSettingsPlugin: ServiceManagerPlugin<Setting.IManager> = {
+  id: '@fails-components/jupyter-applet-widget:settings',
   requires: [],
   autoStart: true,
-  provides: ISettings,
-  activate: (app: JupyterLiteServer) => {
-    if (app.namespace !== 'JupyterLite Server') {
-      console.log('Not on server');
-    }
-    const settings = new FailsSettings();
-    app.started.then(() => settings.initialize().catch(console.warn));
+  provides: ISettingManager,
+  optional: [IServerSettings],
+  activate: (_: null, serverSettings: ServerConnection.ISettings | null) => {
+    const settings = new FailsSettings({
+      serverSettings: serverSettings ?? undefined
+    });
     return settings;
   }
 };
 
-const plugins: JupyterLiteServerPlugin<any>[] = [
-  failsContentsPlugin,
+const plugins: ServiceManagerPlugin<any>[] = [
+  failsDriveMessages,
+  failsDrivePlugin,
   failsSettingsPlugin
 ];
 

package/src/settings.ts

@@ -1,6 +1,6 @@
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
-import { ISettings, IPlugin as ISettingsPlugin } from '@jupyterlite/settings';
-import { PromiseDelegate } from '@lumino/coreutils';
+import { Setting, SettingManager } from '@jupyterlab/services';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import * as json5 from 'json5';
 
 // portions used from Jupyterlab:
@@ -9,13 +9,16 @@ import * as json5 from 'json5';
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 // This code contains portions from or is inspired by Jupyter lab and lite
+export type SettingsFile = 'all.json' | 'all_federated.json';
 
-export class FailsSettings implements ISettings {
+export class FailsSettings extends SettingManager implements Setting.IManager {
   // the following is copied from the original Jupyter Lite Settings Object
-  static _overrides: Record<string, ISettingsPlugin['schema']['default']> =
-    JSON.parse(PageConfig.getOption('settingsOverrides') || '{}');
+  static _overrides: Record<
+    string,
+    ISettingRegistry.IPlugin['schema']['default']
+  > = JSON.parse(PageConfig.getOption('settingsOverrides') || '{}');
 
-  static override(plugin: ISettingsPlugin): ISettingsPlugin {
+  static override(plugin: ISettingRegistry.IPlugin): ISettingRegistry.IPlugin {
     if (FailsSettings._overrides[plugin.id]) {
       if (!plugin.schema.properties) {
         // probably malformed, or only provides keyboard shortcuts, etc.
@@ -30,32 +33,31 @@ export class FailsSettings implements ISettings {
     return plugin;
   }
 
-  constructor() {
-    this._ready = new PromiseDelegate();
-  }
-
-  get ready(): Promise<void> {
-    return this._ready.promise;
-  }
-
-  async initialize() {
-    this._ready.resolve(void 0);
+  constructor(options: SettingManager.IOptions) {
+    super({
+      serverSettings: options.serverSettings
+    });
   }
 
-  // copied from the original settings
-  async get(pluginId: string): Promise<ISettingsPlugin | undefined> {
-    const all = await this.getAll();
-    const settings = all.settings as ISettingsPlugin[];
-    const setting = settings.find((setting: ISettingsPlugin) => {
+  // copied from the original settings (updated)
+  async fetch(pluginId: string): Promise<ISettingRegistry.IPlugin> {
+    const all = await this.list();
+    const settings = all.values as ISettingRegistry.IPlugin[];
+    const setting = settings.find((setting: ISettingRegistry.IPlugin) => {
       return setting.id === pluginId;
     });
+    if (!setting) {
+      throw new Error(`Setting ${pluginId} not found`);
+    }
     return setting;
   }
 
-  // copied from the original settings
-  async getAll(): Promise<{ settings: ISettingsPlugin[] }> {
+  // copied from the original settings (updated)
+  async list(
+    query?: 'ids'
+  ): Promise<{ ids: string[]; values: ISettingRegistry.IPlugin[] }> {
     const allCore = await this._getAll('all.json');
-    let allFederated: ISettingsPlugin[] = [];
+    let allFederated: ISettingRegistry.IPlugin[] = [];
     try {
       allFederated = await this._getAll('all_federated.json');
     } catch {
@@ -78,23 +80,35 @@ export class FailsSettings implements ISettings {
         };
       })
     );
-    return { settings };
+
+    // format the settings
+    const ids =
+      settings.map((plugin: ISettingRegistry.IPlugin) => plugin.id) ?? [];
+
+    let values: ISettingRegistry.IPlugin[] = [];
+    if (!query) {
+      values =
+        settings.map((plugin: ISettingRegistry.IPlugin) => {
+          plugin.data = { composite: {}, user: {} };
+          return plugin;
+        }) ?? [];
+    }
+
+    return { ids, values };
   }
 
   // one to one copy from settings of the original JupyterLite
   private async _getAll(
-    file: 'all.json' | 'all_federated.json'
-  ): Promise<ISettingsPlugin[]> {
+    file: SettingsFile
+  ): Promise<ISettingRegistry.IPlugin[]> {
     const settingsUrl = PageConfig.getOption('settingsUrl') ?? '/';
     const all = (await (
       await fetch(URLExt.join(settingsUrl, file))
-    ).json()) as ISettingsPlugin[];
+    ).json()) as ISettingRegistry.IPlugin[];
     return all;
   }
 
-  async save(pluginId: string, raw: string): Promise<void> {
+  async save(id: string, raw: string): Promise<void> {
     // we do nothing
   }
-
-  private _ready: PromiseDelegate<void>;
 }

package/src/token.ts

@@ -0,0 +1,15 @@
+import { Token } from '@lumino/coreutils';
+import { IContentEventType } from './drive';
+
+export type IFailsDriveMessageHandler = (
+  msg: IContentEventType
+) => Promise<void> | void;
+export interface IFailsDriveMessages {
+  registerMessageHandler: (handler: IFailsDriveMessageHandler) => void;
+  sendMessage: (msg: IContentEventType) => Promise<any>;
+}
+
+export const IFailsDriveMessages = new Token<IFailsDriveMessages>(
+  '@fails-components/jupyter-fails:IFailsDriveMessages',
+  'A service to communicate to the FAILS single file drive.'
+);

package/lib/contents.d.ts

@@ -1,31 +0,0 @@
-import { Contents as ServerContents } from '@jupyterlab/services';
-import { IContents } from '@jupyterlite/contents';
-import { IContentEventType } from '@fails-components/jupyter-launcher';
-export declare class FailsContents implements IContents {
-    constructor();
-    onMessage(event: IContentEventType): Promise<any>;
-    get ready(): Promise<void>;
-    initialize(): Promise<void>;
-    get(path: string, options?: ServerContents.IFetchOptions): Promise<ServerContents.IModel | null>;
-    save(path: string, options?: Partial<ServerContents.IModel>): Promise<ServerContents.IModel | null>;
-    newUntitled(options?: ServerContents.ICreateOptions): Promise<ServerContents.IModel | null>;
-    rename(oldLocalPath: string, newLocalPath: string): Promise<ServerContents.IModel>;
-    delete(path: string): Promise<void>;
-    copy(path: string, toDir: string): Promise<ServerContents.IModel>;
-    createCheckpoint(path: string): Promise<ServerContents.ICheckpointModel>;
-    listCheckpoints(path: string): Promise<ServerContents.ICheckpointModel[]>;
-    restoreCheckpoint(path: string, checkpointID: string): Promise<void>;
-    deleteCheckpoint(path: string, checkpointID: string): Promise<void>;
-    static EMPTY_NB: {
-        metadata: {
-            orig_nbformat: number;
-        };
-        nbformat_minor: number;
-        nbformat: number;
-        cells: never[];
-    };
-    private _ready;
-    private _fileContent;
-    private _fileName;
-    private _failsCallbacks;
-}