jupyterpack 0.3.0 → 0.4.0

package/lib/pythonWidget/comm.js

@@ -0,0 +1,52 @@
+const COMM_NAME = 'jupyterpack:broadcast:comm';
+export class CommBroadcastManager {
+    constructor() {
+        this._handle_comm_open = async (comm, msg, kernelId) => {
+            var _a;
+            if (this._comms.has(kernelId)) {
+                (_a = this._comms.get(kernelId)) === null || _a === void 0 ? void 0 : _a.push(comm);
+            }
+            else {
+                this._comms.set(kernelId, [comm]);
+            }
+            const channelName = msg.metadata.channel_name;
+            if (!channelName) {
+                return;
+            }
+            if (!this._broadcastChannels.has(channelName)) {
+                this._broadcastChannels.set(channelName, new BroadcastChannel(channelName));
+            }
+            const broadcastChannel = this._broadcastChannels.get(channelName);
+            comm.onMsg = commMsg => {
+                const { data } = commMsg.content;
+                broadcastChannel.postMessage(data);
+            };
+        };
+        this._kernels = new Map();
+        this._comms = new Map();
+        this._broadcastChannels = new Map();
+        this._kernels = new Map();
+        this._comms = new Map();
+    }
+    registerKernel(kernel) {
+        this._kernels.set(kernel.id, kernel);
+        kernel.registerCommTarget(COMM_NAME, (comm, msg) => this._handle_comm_open(comm, msg, kernel.id));
+    }
+    unregisterKernel(kernelId) {
+        var _a;
+        if (kernelId) {
+            this._kernels.delete(kernelId);
+            const comms = (_a = this._comms.get(kernelId)) !== null && _a !== void 0 ? _a : [];
+            comms.forEach(comm => comm.dispose());
+            this._comms.delete(kernelId);
+        }
+    }
+    dispose() {
+        this._kernels.clear();
+        this._comms.clear();
+        this._broadcastChannels.forEach(it => {
+            it.close();
+        });
+        this._broadcastChannels.clear();
+    }
+}

package/lib/pythonWidget/pythonWidget.d.ts

@@ -2,9 +2,14 @@ import { PythonWidgetModel } from './pythonWidgetModel';
 import { IFramePanel } from '../document/iframePanel';
 export declare class PythonWidget extends IFramePanel {
     constructor(options: PythonWidget.IOptions);
+    get autoreload(): boolean;
+    set autoreload(value: boolean);
+    get isReady(): Promise<void>;
     get model(): PythonWidgetModel;
+    reload(): Promise<void>;
     dispose(): void;
     private _model;
+    private _isReady;
 }
 export declare namespace PythonWidget {
     interface IOptions {

package/lib/pythonWidget/pythonWidget.js

@@ -1,8 +1,10 @@
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { IFramePanel } from '../document/iframePanel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class PythonWidget extends IFramePanel {
     constructor(options) {
         super();
+        this._isReady = new PromiseDelegate();
         this._model = options.model;
         this._model.initialize().then(connectionData => {
             if (!connectionData.success) {
@@ -10,6 +12,7 @@ export class PythonWidget extends IFramePanel {
                 this._iframe.contentDocument.body.innerText = `Failed to start server: ${connectionData.error}`;
                 return;
             }
+            this._isReady.resolve();
             const iframe = this._iframe;
             const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
             const iframeUrl = URLExt.join(fullLabextensionsUrl, 'jupyterpack/static', connectionData.instanceId, connectionData.framework, connectionData.kernelClientId, connectionData.rootUrl);
@@ -17,11 +20,27 @@ export class PythonWidget extends IFramePanel {
             iframe.addEventListener('load', () => {
                 this.toggleSpinner(false);
             });
+            this._model.serverReloaded.connect(() => {
+                var _a, _b, _c;
+                (_c = (_b = (_a = this._iframe) === null || _a === void 0 ? void 0 : _a.contentWindow) === null || _b === void 0 ? void 0 : _b.location) === null || _c === void 0 ? void 0 : _c.reload();
+            });
         });
     }
+    get autoreload() {
+        return this._model.autoreload;
+    }
+    set autoreload(value) {
+        this._model.autoreload = value;
+    }
+    get isReady() {
+        return this._isReady.promise;
+    }
     get model() {
         return this._model;
     }
+    async reload() {
+        await this._model.reload();
+    }
     dispose() {
         this._model.dispose();
     }

package/lib/pythonWidget/pythonWidgetModel.d.ts

@@ -1,11 +1,16 @@
 import { DocumentRegistry } from '@jupyterlab/docregistry';
 import { Contents, ServiceManager } from '@jupyterlab/services';
-import { IDisposable } from '@lumino/disposable';
-import { IConnectionManager, IJupyterPackFileFormat, JupyterPackFramework } from '../type';
-export declare class PythonWidgetModel implements IDisposable {
+import { Signal } from '@lumino/signaling';
+import { IConnectionManager, IJupyterPackFileFormat, IPythonWidgetModel, JupyterPackFramework } from '../type';
+export declare class PythonWidgetModel implements IPythonWidgetModel {
     constructor(options: PythonWidgetModel.IOptions);
+    get autoreload(): boolean;
+    set autoreload(val: boolean);
     get isDisposed(): boolean;
     get connectionManager(): IConnectionManager;
+    get serverReloaded(): Signal<IPythonWidgetModel, void>;
+    get kernelStatusChanged(): Signal<IPythonWidgetModel, "started" | "stopped">;
+    reload(): Promise<void>;
     initialize(): Promise<{
         success: true;
         instanceId: string;
@@ -16,7 +21,10 @@ export declare class PythonWidgetModel implements IDisposable {
         success: false;
         error: string;
     }>;
-    dispose(): void;
+    dispose(): Promise<void>;
+    private _loadData;
+    private _onFileChanged;
+    private _commBroadcastManager;
     private _isDisposed;
     private _kernelStarted;
     private _sessionConnection;
@@ -26,6 +34,10 @@ export declare class PythonWidgetModel implements IDisposable {
     private _contentsManager;
     private _jpackModel;
     private _executor?;
+    private _localPath;
+    private _serverReloaded;
+    private _kernelStatusChanged;
+    private _autoreload;
 }
 export declare namespace PythonWidgetModel {
     interface IOptions {

package/lib/pythonWidget/pythonWidgetModel.js

@@ -1,15 +1,31 @@
 import { PathExt } from '@jupyterlab/coreutils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { PYTHON_SERVER } from '../pythonServer';
+import { Signal } from '@lumino/signaling';
+import { CommBroadcastManager } from './comm';
+import { IS_LITE } from '../tools';
 export class PythonWidgetModel {
     constructor(options) {
+        var _a, _b;
+        this._commBroadcastManager = new CommBroadcastManager();
         this._isDisposed = false;
         this._kernelStarted = false;
+        this._serverReloaded = new Signal(this);
+        this._kernelStatusChanged = new Signal(this);
         this._context = options.context;
         this._manager = options.manager;
         this._connectionManager = options.connectionManager;
         this._contentsManager = options.contentsManager;
         this._jpackModel = options.jpackModel;
+        this._localPath = PathExt.dirname(this._context.localPath);
+        this._autoreload = Boolean((_b = (_a = this._jpackModel) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.autoreload);
+        this._contentsManager.fileChanged.connect(this._onFileChanged, this);
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
     }
     get isDisposed() {
         return this._isDisposed;
@@ -17,22 +33,33 @@ export class PythonWidgetModel {
     get connectionManager() {
         return this._connectionManager;
     }
+    get serverReloaded() {
+        return this._serverReloaded;
+    }
+    get kernelStatusChanged() {
+        return this._kernelStatusChanged;
+    }
+    async reload() {
+        var _a;
+        if (!this._kernelStarted) {
+            return;
+        }
+        const { spkContent, entryContent } = await this._loadData();
+        await ((_a = this._executor) === null || _a === void 0 ? void 0 : _a.reloadPythonServer({
+            entryPath: spkContent.entry,
+            initCode: entryContent.content
+        }));
+        this._serverReloaded.emit();
+    }
     async initialize() {
-        var _a, _b;
+        var _a;
         if (this._kernelStarted) {
             return {
                 success: false,
                 error: 'Server is called twice'
             };
         }
-        const filePath = this._context.localPath;
-        const spkContent = this._jpackModel;
-        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
-        const rootUrl = (_a = spkContent.rootUrl) !== null && _a !== void 0 ? _a : '/';
-        const entryContent = await this._contentsManager.get(entryPath, {
-            content: true,
-            format: 'text'
-        });
+        const { filePath, spkContent, rootUrl, entryContent } = await this._loadData();
         const sessionManager = this._manager.sessions;
         await sessionManager.ready;
         await this._manager.kernelspecs.ready;
@@ -55,7 +82,18 @@ export class PythonWidgetModel {
                 name: kernelName
             },
             type: 'notebook'
+        }, {
+            kernelConnectionOptions: { handleComms: true }
         });
+        const kernel = this._sessionConnection.kernel;
+        if (kernel) {
+            this._kernelStatusChanged.emit('started');
+            this._commBroadcastManager.registerKernel(kernel);
+            kernel.disposed.connect(() => {
+                this._kernelStatusChanged.emit('stopped');
+                this._commBroadcastManager.unregisterKernel(kernel.id);
+            });
+        }
         const framework = spkContent.framework;
         const ServerClass = PYTHON_SERVER.get(framework);
         if (!ServerClass) {
@@ -81,17 +119,43 @@ export class PythonWidgetModel {
                 finish.resolve();
             }
         };
-        (_b = this._sessionConnection.kernel) === null || _b === void 0 ? void 0 : _b.statusChanged.connect(cb);
+        (_a = this._sessionConnection.kernel) === null || _a === void 0 ? void 0 : _a.statusChanged.connect(cb);
         await finish.promise;
         this._kernelStarted = true;
         return { ...data, rootUrl, framework, success: true };
     }
-    dispose() {
-        var _a;
+    async dispose() {
+        var _a, _b, _c;
         if (this._isDisposed) {
             return;
         }
-        void ((_a = this._executor) === null || _a === void 0 ? void 0 : _a.disposePythonServer());
+        if (!IS_LITE) {
+            (_b = (_a = this._sessionConnection) === null || _a === void 0 ? void 0 : _a.kernel) === null || _b === void 0 ? void 0 : _b.shutdown();
+        }
+        void ((_c = this._executor) === null || _c === void 0 ? void 0 : _c.disposePythonServer());
+        this._contentsManager.fileChanged.disconnect(this._onFileChanged);
+        this._commBroadcastManager.dispose();
         this._isDisposed = true;
     }
+    async _loadData() {
+        var _a;
+        const filePath = this._context.localPath;
+        const spkContent = this._jpackModel;
+        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
+        const rootUrl = (_a = spkContent.rootUrl) !== null && _a !== void 0 ? _a : '/';
+        const entryContent = await this._contentsManager.get(entryPath, {
+            content: true,
+            format: 'text'
+        });
+        return { filePath, spkContent, rootUrl, entryContent };
+    }
+    async _onFileChanged(sender, args) {
+        var _a;
+        if (this._autoreload && args.type === 'save') {
+            if (((_a = args.newValue) === null || _a === void 0 ? void 0 : _a.path) &&
+                args.newValue.path.startsWith(this._localPath)) {
+                await this.reload();
+            }
+        }
+    }
 }

package/lib/sandpackWidget/sandpackFilesModel.d.ts

@@ -1,19 +1,22 @@
 import { Contents } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
 import { IDict } from '../type';
-export declare class SandpackFilesModel {
+import { IDisposable } from '@lumino/disposable';
+export declare class SandpackFilesModel implements IDisposable {
     constructor(options: {
         contentsManager: Contents.IManager;
         path: string;
     });
-    getAllFiles(): Promise<IDict<{
+    getAllFiles(force?: boolean): Promise<IDict<{
         code: string;
     }>>;
+    get isDisposed(): boolean;
     get fileChanged(): ISignal<SandpackFilesModel, {
         allFiles: IDict<{
             code: string;
         }>;
     }>;
+    dispose(): void;
     flattenDirectory(dirContent: Contents.IModel): Promise<IDict<{
         code: string;
     }>>;
@@ -24,4 +27,5 @@ export declare class SandpackFilesModel {
     private _fileChanged;
     private _contentManager;
     private _allFiles?;
+    private _isDisposed;
 }

package/lib/sandpackWidget/sandpackFilesModel.js

@@ -3,12 +3,13 @@ import { removePrefix } from '../tools';
 export class SandpackFilesModel {
     constructor(options) {
         this._fileChanged = new Signal(this);
+        this._isDisposed = false;
         this._contentManager = options.contentsManager;
         this._path = options.path;
         this._contentManager.fileChanged.connect(this._onFileChanged, this);
     }
-    async getAllFiles() {
-        if (!this._allFiles) {
+    async getAllFiles(force = false) {
+        if (!this._allFiles || force) {
             const files = await this._contentManager.get(this._path, {
                 content: true
             });
@@ -16,9 +17,19 @@ export class SandpackFilesModel {
         }
         return this._allFiles;
     }
+    get isDisposed() {
+        return this._isDisposed;
+    }
     get fileChanged() {
         return this._fileChanged;
     }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._contentManager.fileChanged.disconnect(this._onFileChanged);
+    }
     async flattenDirectory(dirContent) {
         const flatDict = {};
         const content = dirContent.content;

package/lib/sandpackWidget/sandpackPanel.d.ts

@@ -2,15 +2,24 @@ import { SandpackClient } from '@codesandbox/sandpack-client';
 import { DocumentRegistry } from '@jupyterlab/docregistry';
 import { Contents } from '@jupyterlab/services';
 import { IFramePanel } from '../document/iframePanel';
+import { IJupyterPackFileFormat } from '../type';
 import { SandpackFilesModel } from './sandpackFilesModel';
 export declare class SandpackPanel extends IFramePanel {
     constructor(options: {
         context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
         contentsManager: Contents.IManager;
     });
-    init(localPath: string): Promise<void>;
+    dispose(): void;
+    get isReady(): Promise<void>;
+    get autoreload(): boolean;
+    set autoreload(val: boolean);
+    init(localPath: string, jpackModel: IJupyterPackFileFormat): Promise<void>;
     connectSignals(filesModel: SandpackFilesModel, sandpackClient: SandpackClient): Promise<void>;
+    reload(): Promise<void>;
     private _onFileChanged;
     private _spClient?;
     private _contentsManager;
+    private _fileModel;
+    private _autoreload;
+    private _isReady;
 }

package/lib/sandpackWidget/sandpackPanel.js

@@ -1,20 +1,46 @@
 import { loadSandpackClient } from '@codesandbox/sandpack-client';
 import { IFramePanel } from '../document/iframePanel';
 import { SandpackFilesModel } from './sandpackFilesModel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class SandpackPanel extends IFramePanel {
     constructor(options) {
         super();
+        this._autoreload = false;
+        this._isReady = new PromiseDelegate();
         this._contentsManager = options.contentsManager;
+        const { context } = options;
         options.context.ready.then(async () => {
-            await this.init(options.context.localPath);
+            const jpackModel = context.model.toJSON();
+            await this.init(context.localPath, jpackModel);
         });
     }
-    async init(localPath) {
+    dispose() {
+        var _a, _b, _c;
+        (_a = this._fileModel) === null || _a === void 0 ? void 0 : _a.fileChanged.disconnect(this._onFileChanged);
+        (_b = this._fileModel) === null || _b === void 0 ? void 0 : _b.dispose();
+        (_c = this._spClient) === null || _c === void 0 ? void 0 : _c.destroy();
+        super.dispose();
+    }
+    get isReady() {
+        return this._isReady.promise;
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
+    }
+    async init(localPath, jpackModel) {
+        var _a;
+        if (((_a = jpackModel === null || jpackModel === void 0 ? void 0 : jpackModel.metadata) === null || _a === void 0 ? void 0 : _a.autoreload) === true) {
+            this._autoreload = true;
+        }
         const currentDir = localPath.split('/').slice(0, -1).join('/');
         const filesModel = new SandpackFilesModel({
             contentsManager: this._contentsManager,
             path: currentDir
         });
+        this._fileModel = filesModel;
         const allFiles = await filesModel.getAllFiles();
         const options = {
             showLoadingScreen: true,
@@ -24,6 +50,7 @@ export class SandpackPanel extends IFramePanel {
             files: allFiles
         }, options);
         await this.connectSignals(filesModel, this._spClient);
+        this._isReady.resolve();
     }
     async connectSignals(filesModel, sandpackClient) {
         filesModel.fileChanged.connect(this._onFileChanged, this);
@@ -42,8 +69,16 @@ export class SandpackPanel extends IFramePanel {
             }
         });
     }
+    async reload() {
+        if (this._spClient && this._fileModel) {
+            const allFiles = await this._fileModel.getAllFiles();
+            this._spClient.updateSandbox({
+                files: allFiles
+            });
+        }
+    }
     _onFileChanged(sender, { allFiles }) {
-        if (this._spClient) {
+        if (this._autoreload && this._spClient) {
             this._spClient.updateSandbox({
                 files: allFiles
             });

package/lib/token.d.ts

@@ -1,3 +1,4 @@
 import { Token } from '@lumino/coreutils';
-import { IConnectionManager } from './type';
+import { IConnectionManager, IJupyterpackDocTracker } from './type';
 export declare const IConnectionManagerToken: Token<IConnectionManager>;
+export declare const IJupyterpackDocTrackerToken: Token<IJupyterpackDocTracker>;

package/lib/token.js

@@ -1,2 +1,3 @@
 import { Token } from '@lumino/coreutils';
 export const IConnectionManagerToken = new Token('jupyterpack:connection-manager');
+export const IJupyterpackDocTrackerToken = new Token('jupyterpack:dock-tracker');

package/lib/tools.d.ts

@@ -1,3 +1,8 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+export declare const IS_LITE: boolean;
+export declare const logoIcon: LabIcon;
+export declare const autoReloadIcon: LabIcon;
+export declare const linkIcon: LabIcon;
 export declare function removePrefix(path: string, prefix: string): string;
 export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
 export declare function base64ToArrayBuffer(base64: string): Uint8Array;

package/lib/tools.js

@@ -1,3 +1,20 @@
+import logoStr from '../style/icons/box.svg';
+import autoReloadStr from '../style/icons/autoreload.svg';
+import linkStr from '../style/icons/externallink.svg';
+import { LabIcon } from '@jupyterlab/ui-components';
+export const IS_LITE = !!document.getElementById('jupyter-lite-main');
+export const logoIcon = new LabIcon({
+    name: 'jupyterpack:logo',
+    svgstr: logoStr
+});
+export const autoReloadIcon = new LabIcon({
+    name: 'jupyterpack:autoReload',
+    svgstr: autoReloadStr
+});
+export const linkIcon = new LabIcon({
+    name: 'jupyterpack:externalLink',
+    svgstr: linkStr
+});
 export function removePrefix(path, prefix) {
     if (path.startsWith(prefix)) {
         return path.slice(prefix.length);

package/lib/type.d.ts

@@ -1,5 +1,8 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
 import { KernelMessage } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { ISignal } from '@lumino/signaling';
 export interface IDict<T = any> {
     [key: string]: T;
 }
@@ -19,7 +22,9 @@ export interface IJupyterPackFileFormat {
     entry: string;
     framework: JupyterPackFramework;
     name?: string;
-    metadata?: IDict;
+    metadata?: {
+        autoreload?: boolean;
+    };
     rootUrl?: string;
 }
 export declare enum MessageAction {
@@ -54,6 +59,10 @@ export interface IKernelExecutor extends IDisposable {
         kernelClientId: string;
     }): Promise<void>;
     disposePythonServer(): Promise<void>;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
     getResponseFunctionFactory(options: {
         urlPath: string;
         method: string;
@@ -71,3 +80,20 @@ export interface IConnectionManager {
         kernelClientId: string;
     } & IKernelExecutorParams): Promise<IDict | null>;
 }
+export type IJupyterpackDocTracker = IWidgetTracker<DocumentWidget>;
+export interface IPythonWidgetModel extends IDisposable {
+    connectionManager: IConnectionManager;
+    serverReloaded: ISignal<IPythonWidgetModel, void>;
+    kernelStatusChanged: ISignal<IPythonWidgetModel, 'started' | 'stopped'>;
+    reload(): Promise<void>;
+    initialize(): Promise<{
+        success: true;
+        instanceId: string;
+        kernelClientId: string;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+    } | {
+        success: false;
+        error: string;
+    }>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterpack",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "A JupyterLab extension for serving web app.",
     "keywords": [
         "jupyter",
@@ -29,13 +29,12 @@
         "url": "https://github.com/trungleduc/jupyterpack.git"
     },
     "scripts": {
-        "build:demo": "cd demo && rm -rf .jupyterlite.doit.db _output && jupyter lite build .",
+        "build:demo": "node script/build-demo.mjs",
         "update:demo": "node script/update-demo.mjs",
-        "combine:python": "node script/combine-python.mjs",
         "build:worker": "webpack --config sw.webpack.config.js --mode development",
         "build:worker:prod": "webpack --config sw.webpack.config.js --mode production",
-        "build": "jlpm combine:python && jlpm build:lib && jlpm build:labextension:dev && jlpm build:worker",
-        "build:prod": "jlpm clean && jlpm combine:python && jlpm build:lib:prod && jlpm build:labextension && jlpm build:worker:prod",
+        "build": "jlpm build:lib && jlpm build:labextension:dev && jlpm build:worker",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension && jlpm build:worker:prod",
         "build:labextension": "jupyter labextension build .",
         "build:labextension:dev": "jupyter labextension build --development True .",
         "build:lib": "tsc --sourceMap",
@@ -80,7 +79,7 @@
         "eslint-plugin-prettier": "^5.0.0",
         "npm-run-all2": "^7.0.1",
         "prettier": "^3.0.0",
-        "rimraf": "^5.0.1",
+        "rimraf": "^6.1.0",
         "source-map-loader": "^1.0.2",
         "style-loader": "^3.3.1",
         "stylelint": "^15.10.1",
@@ -88,6 +87,7 @@
         "stylelint-config-standard": "^34.0.0",
         "stylelint-csstree-validator": "^3.0.0",
         "stylelint-prettier": "^4.0.0",
+        "tar": "^7.5.2",
         "ts-loader": "^9.2.6",
         "typescript": "~5.8.0",
         "webpack": "^5.76.3",