@basthon/gui-base 0.37.2 → 0.38.3

package/lib/main.d.ts

@@ -1,5 +1,15 @@
 import { KernelBase } from "@basthon/kernel-base";
 import { KernelLoader } from "@basthon/kernel-loader";
+declare global {
+    interface Window {
+        _basthonEmptyContent?: any;
+    }
+}
+export interface GUIOptions {
+    kernelRootPath: string;
+    language: string;
+    uiName?: string;
+}
 /**
  * Base class for console and notebook GUI.
  */
@@ -7,8 +17,12 @@ export declare class GUIBase {
     private readonly _language;
     private readonly _loaded;
     private _loader;
+    private _checkpoints;
+    private _maxCheckpoints;
+    protected _contentFilename: string;
+    protected _urlKey: string;
     private _console_error;
-    constructor(kernelRootPath: string, language: string);
+    constructor(options: GUIOptions);
     /**
      * Language getter.
      */
@@ -53,6 +67,46 @@ export declare class GUIBase {
      * Initialize the GUI.
      */
     init(options?: any): Promise<void>;
+    /**
+     * Get the content (script or notebook content).
+     */
+    content(): string;
+    /**
+     * Set the content (script or notebook content).
+     */
+    setContent(content: string): void;
+    /**
+     * Loading the content from query string (ipynb=/script= or from=).
+     */
+    loadFromQS(key: string): Promise<string | null>;
+    /**
+     * Setup the UI (typically connect events etc..).
+     */
+    protected setupUI(options: any): Promise<void>;
+    /**
+     * Load content at startup.
+     */
+    protected loadInitialContent(options: any): Promise<void>;
+    /**
+     * Load content from local forage.
+     */
+    protected loadFromStorage(): Promise<string | null>;
+    /**
+     * Tag last backup as "approved".
+     */
+    validateBackup(): Promise<void>;
+    /**
+     * Select a checkpoint to load in the script.
+     */
+    selectCheckpoint(): Promise<string | null>;
+    /**
+     * Backup to checkpoints.
+     */
+    backup(approved?: boolean): Promise<string>;
+    /**
+     * Internal GUI init.
+     * It calls setupUI then loadInitialContent.
+     */
     protected _init(options?: any): Promise<void>;
     /**
      * Change loader text and call init function.
@@ -97,10 +151,22 @@ export declare class GUIBase {
      * Open an URL in a new tab or download a file.
      */
     static openURL(url: string, download?: string): void;
+    /**
+     * Returning the sharing link for the content.
+     */
+    sharingURL(key: string): Promise<string>;
     /**
      * Share content via URL.
      */
-    protected _share(url: string, message: string): Promise<void>;
+    protected share(): Promise<void>;
+    /**
+     * Opening file (async) and load its content.
+     */
+    open(file: Blob | File): Promise<void>;
+    /**
+     * Download content to file.
+     */
+    download(): void;
     /**
      * Copy a text to clipboard.
      */

package/lib/main.js

@@ -1,18 +1,24 @@
 import { PromiseDelegate } from "promise-delegate";
+import { CheckpointsManager } from "@basthon/checkpoints";
 import { KernelBase } from "@basthon/kernel-base";
 import { KernelLoader } from "@basthon/kernel-loader";
 /**
  * Base class for console and notebook GUI.
  */
 export class GUIBase {
-    constructor(kernelRootPath, language) {
+    constructor(options) {
         this._loaded = new PromiseDelegate();
+        this._maxCheckpoints = 5;
+        this._contentFilename = "content.txt";
+        this._urlKey = "content";
         /* console errors redirected to notification system */
         this._console_error = console.error;
-        this._language = language;
-        this._loader = new KernelLoader(kernelRootPath, language);
+        this._language = options.language;
+        this._loader = new KernelLoader(options.kernelRootPath, options.language);
         // loading Basthon (errors are fatal)
         this._loader.showLoader("Chargement de Basthon...", false, false);
+        /* per language checkpoints */
+        this._checkpoints = new CheckpointsManager(`${options.uiName}.${options.language}`, this._maxCheckpoints);
     }
     /**
      * Language getter.
@@ -78,12 +84,154 @@ export class GUIBase {
             this._loaded.reject(error);
         }
     }
+    /**
+     * Get the content (script or notebook content).
+     */
+    content() { return ""; }
+    /**
+     * Set the content (script or notebook content).
+     */
+    setContent(content) { }
+    /**
+     * Loading the content from query string (ipynb=/script= or from=).
+     */
+    async loadFromQS(key) {
+        const url = new URL(window.location.href);
+        const from_key = 'from';
+        let content = null;
+        if (url.searchParams.has(key)) {
+            content = url.searchParams.get(key) || "";
+            try {
+                content = await this.inflate(content);
+            }
+            catch (error) {
+                /* backward compatibility with non compressed param */
+                if (content != null)
+                    content = decodeURIComponent(content);
+            }
+        }
+        else if (url.searchParams.has(from_key)) {
+            let fileURL = url.searchParams.get(from_key);
+            if (fileURL != null)
+                fileURL = decodeURIComponent(fileURL);
+            try {
+                content = await GUIBase.xhr({
+                    url: fileURL,
+                    method: 'GET'
+                });
+            }
+            catch (error) {
+                const message = `Le chargement de ${fileURL} a échoué.`;
+                throw new ErrorEvent(message, { message: message });
+            }
+        }
+        if (content != null)
+            this.setContent(content);
+        return content;
+    }
+    /**
+     * Setup the UI (typically connect events etc..).
+     */
+    async setupUI(options) {
+        this.kernelLoader.kernelAvailable().then((kernel) => {
+            // this is ugly but it seems complicated to make
+            // GUI available in websocket for the notebook
+            // so patch it!
+            const dispatchEvent = kernel.dispatchEvent.bind(this.kernel);
+            kernel.dispatchEvent = async (event, data) => {
+                if (event === "eval.request")
+                    await this.backup(false);
+                dispatchEvent(event, data);
+            };
+            kernel.addEventListener("eval.finished", () => {
+                this.validateBackup();
+            });
+            kernel.addEventListener("eval.error", () => {
+                this.validateBackup();
+            });
+        });
+    }
+    /**
+     * Load content at startup.
+     */
+    async loadInitialContent(options) {
+        if (window._basthonEmptyContent)
+            return;
+        if (await this.loadFromQS(this._urlKey) != null)
+            return;
+        this.loadFromStorage();
+    }
+    /**
+     * Load content from local forage.
+     */
+    async loadFromStorage() {
+        const approved = await this._checkpoints.lastHasTag("approved");
+        let content = null;
+        if (approved == null) {
+            content = null;
+        }
+        else if (approved) {
+            content = await this._checkpoints.getLast();
+        }
+        else {
+            const promise = new PromiseDelegate();
+            this.confirm("Récupération", "Il semble que Basthon ait rencontré un problème à sa dernière utilisation. Que voulez-vous faire ?", "Choisir une sauvegarde", async () => {
+                promise.resolve(await this.selectCheckpoint());
+            }, "Laisser le document vide", () => { promise.resolve(null); });
+            content = await promise.promise;
+        }
+        if (content != null)
+            this.setContent(content);
+        return content;
+    }
+    /**
+     * Tag last backup as "approved".
+     */
+    async validateBackup() {
+        await this._checkpoints.tagLast("approved");
+    }
+    /**
+     * Select a checkpoint to load in the script.
+     */
+    async selectCheckpoint() {
+        const times = await this._checkpoints.times();
+        const promise = new PromiseDelegate();
+        const choices = times === null || times === void 0 ? void 0 : times.map((t, i) => ({
+            text: CheckpointsManager.toHumanDate(parseInt(t, 10)),
+            handler: async () => { var _a; promise.resolve((_a = (await this._checkpoints.getIndex(i))) !== null && _a !== void 0 ? _a : null); }
+        }));
+        if (choices == null)
+            return null;
+        this.select("Choisissez une sauvegarde", "De quelle sauvegarde souhaitez-vous reprendre ?", choices, "Annuler", () => { promise.resolve(null); });
+        return await promise.promise;
+    }
+    /**
+     * Backup to checkpoints.
+     */
+    async backup(approved = true) {
+        return await this._checkpoints.push(this.content(), approved ? ["approved"] : []);
+    }
+    /**
+     * Internal GUI init.
+     * It calls setupUI then loadInitialContent.
+     */
     async _init(options = null) {
         /* all errors redirected to notification system */
         const onerror = this.notifyError.bind(this);
         window.addEventListener('error', onerror);
         window.addEventListener("unhandledrejection", onerror);
         console.error = (message) => onerror(new ErrorEvent(message, { message: message }));
+        await this._checkpoints.ready();
+        await this.setupUI(options);
+        await this.loadInitialContent(options);
+        await this.kernelLoader.kernelLoaded();
+        const init = this.initCaller.bind(this);
+        // loading aux files from URL
+        await init(this.loadURLAux.bind(this), "Chargement des fichiers auxiliaires...", true);
+        // loading modules from URL
+        await init(this.loadURLModules.bind(this), "Chargement des modules annexes...", true);
+        // end
+        this.kernelLoader.hideLoader();
     }
     /**
      * Change loader text and call init function.
@@ -211,11 +359,58 @@ export class GUIBase {
         anchor.click();
         document.body.removeChild(anchor);
     }
+    /**
+     * Returning the sharing link for the content.
+     */
+    async sharingURL(key) {
+        // to retain the Line breaks.
+        let content = this.content().replace(/\r\n|\r|\n/g, "\r\n");
+        const url = new URL(window.location.href);
+        url.hash = "";
+        url.searchParams.delete("from"); // take care of collapsing params
+        try {
+            content = await this.deflate(content);
+        }
+        catch (e) { // fallback
+            content = encodeURIComponent(content).replace(/\(/g, '%28').replace(/\)/g, '%29');
+        }
+        url.searchParams.set(key, content);
+        return url.href;
+    }
     /**
      * Share content via URL.
      */
-    async _share(url, message) {
-        this.confirm("Partager ce notebook", message, "Copier dans le presse-papier", () => GUIBase.copyToClipboard(url), "Tester le lien", () => GUIBase.openURL(url));
+    async share() {
+        const url = await this.sharingURL(this._urlKey);
+        const message = `
+Un lien permanant vers le contenu actuel a été créé.
+<br>
+<i class="fas fa-exclamation-circle"></i> Attention, partager un document trop long peut ne pas fonctionner avec certains navigateurs.`;
+        this.confirm("Partager ce document", message, "Copier dans le presse-papier", () => GUIBase.copyToClipboard(url), "Tester le lien", () => GUIBase.openURL(url));
+    }
+    /**
+     * Opening file (async) and load its content.
+     */
+    open(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsText(file);
+            reader.onload = (event) => {
+                var _a;
+                this.setContent((_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.result);
+                resolve();
+            };
+            reader.onerror = reject;
+        });
+    }
+    /**
+     * Download content to file.
+     */
+    download() {
+        this.backup();
+        const content = this.content().replace(/\r\n|\r|\n/g, "\r\n"); // To retain the Line breaks.
+        let blob = new Blob([content], { type: "text/plain" });
+        GUIBase.openURL(window.URL.createObjectURL(blob), this._contentFilename);
     }
     /**
      * Binding to kernel's XHR.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basthon/gui-base",
-  "version": "0.37.2",
+  "version": "0.38.3",
   "description": "Basthon - Base GUI",
   "homepage": "https://basthon.fr",
   "bugs": {
@@ -25,8 +25,9 @@
     "clean": "rm -rf lib/"
   },
   "dependencies": {
-    "@basthon/kernel-base": "^0.37.2",
-    "@basthon/kernel-loader": "^0.37.2",
+    "@basthon/checkpoints": "^0.38.3",
+    "@basthon/kernel-base": "^0.38.3",
+    "@basthon/kernel-loader": "^0.38.3",
     "js-base64": "^3.7.2",
     "pako": "^2.0.4",
     "promise-delegate": "^1.0.1"
@@ -40,5 +41,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "21ef9a596b7e9c098a2b72ddd406cbb50577adb0"
+  "gitHead": "193136a6ba876d31b2960d72fb8325fddaa24af1"
 }