@jupyterlab/application 0.19.1-alpha.0 → 0.19.1

package/lib/layoutrestorer.js

@@ -1,423 +1,423 @@
-"use strict";
-/*-----------------------------------------------------------------------------
-| Copyright (c) Jupyter Development Team.
-| Distributed under the terms of the Modified BSD License.
-|----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const coreutils_1 = require("@phosphor/coreutils");
-const properties_1 = require("@phosphor/properties");
-/* tslint:disable */
-/**
- * The layout restorer token.
- */
-exports.ILayoutRestorer = new coreutils_1.Token('@jupyterlab/application:ILayoutRestorer');
-/**
- * The state database key for restorer data.
- */
-const KEY = 'layout-restorer:data';
-/**
- * The default implementation of a layout restorer.
- *
- * #### Notes
- * The lifecycle for state restoration is subtle. The sequence of events is:
- *
- * 1. The layout restorer plugin is instantiated and makes a `fetch` call to
- *    the database that stores the layout restoration data. The `fetch` call
- *    returns a promise that resolves in step 6, below.
- *
- * 2. Other plugins that care about state restoration require the layout
- *    restorer as a dependency.
- *
- * 3. As each load-time plugin initializes (which happens before the lab
- *    application has `started`), it instructs the layout restorer whether
- *    the restorer ought to `restore` its state by passing in its tracker.
- *    Alternatively, a plugin that does not require its own instance tracker
- *    (because perhaps it only creates a single widget, like a command palette),
- *    can simply `add` its widget along with a persistent unique name to the
- *    layout restorer so that its layout state can be restored when the lab
- *    application restores.
- *
- * 4. After all the load-time plugins have finished initializing, the lab
- *    application `started` promise will resolve. This is the `first`
- *    promise that the layout restorer waits for. By this point, all of the
- *    plugins that care about restoration will have instructed the layout
- *    restorer to `restore` their state.
- *
- * 5. The layout restorer will then instruct each plugin's instance tracker
- *    to restore its state and reinstantiate whichever widgets it wants. The
- *    tracker returns a promise to the layout restorer that resolves when it
- *    has completed restoring the tracked widgets it cares about.
- *
- * 6. As each instance tracker finishes restoring the widget instances it cares
- *    about, it resolves the promise that was made to the layout restorer
- *    (in step 5). After all of the promises that the restorer is awaiting have
- *    resolved, the restorer then resolves the outstanding `fetch` promise
- *    (from step 1) and hands off a layout state object to the application
- *    shell's `restoreLayout` method for restoration.
- *
- * 7. Once the application shell has finished restoring the layout, the
- *    JupyterLab application's `restored` promise is resolved.
- *
- * Of particular note are steps 5 and 6: since state restoration of plugins
- * is accomplished by executing commands, the command that is used to restore
- * the state of each plugin must return a promise that only resolves when the
- * widget has been created and added to the plugin's instance tracker.
- */
-class LayoutRestorer {
-    /**
-     * Create a layout restorer.
-     */
-    constructor(options) {
-        this._firstDone = false;
-        this._promisesDone = false;
-        this._promises = [];
-        this._restored = new coreutils_1.PromiseDelegate();
-        this._trackers = new Set();
-        this._widgets = new Map();
-        this._registry = options.registry;
-        this._state = options.state;
-        this._first = options.first;
-        this._first
-            .then(() => {
-            this._firstDone = true;
-        })
-            .then(() => Promise.all(this._promises))
-            .then(() => {
-            this._promisesDone = true;
-            // Release the tracker set.
-            this._trackers.clear();
-        })
-            .then(() => {
-            this._restored.resolve(void 0);
-        });
-    }
-    /**
-     * A promise resolved when the layout restorer is ready to receive signals.
-     */
-    get restored() {
-        return this._restored.promise;
-    }
-    /**
-     * Add a widget to be tracked by the layout restorer.
-     */
-    add(widget, name) {
-        Private.nameProperty.set(widget, name);
-        this._widgets.set(name, widget);
-        widget.disposed.connect(this._onWidgetDisposed, this);
-    }
-    /**
-     * Fetch the layout state for the application.
-     *
-     * #### Notes
-     * Fetching the layout relies on all widget restoration to be complete, so
-     * calls to `fetch` are guaranteed to return after restoration is complete.
-     */
-    fetch() {
-        const blank = {
-            fresh: true,
-            mainArea: null,
-            leftArea: null,
-            rightArea: null
-        };
-        let layout = this._state.fetch(KEY);
-        return Promise.all([layout, this.restored])
-            .then(([data]) => {
-            if (!data) {
-                return blank;
-            }
-            const { main, left, right } = data;
-            // If any data exists, then this is not a fresh session.
-            const fresh = false;
-            // Rehydrate main area.
-            const mainArea = this._rehydrateMainArea(main);
-            // Rehydrate left area.
-            const leftArea = this._rehydrateSideArea(left);
-            // Rehydrate right area.
-            const rightArea = this._rehydrateSideArea(right);
-            return { fresh, mainArea, leftArea, rightArea };
-        })
-            .catch(() => blank); // Let fetch fail gracefully; return blank slate.
-    }
-    /**
-     * Restore the widgets of a particular instance tracker.
-     *
-     * @param tracker - The instance tracker whose widgets will be restored.
-     *
-     * @param options - The restoration options.
-     */
-    restore(tracker, options) {
-        const warning = 'restore() can only be called before `first` has resolved.';
-        if (this._firstDone) {
-            console.warn(warning);
-            return Promise.reject(warning);
-        }
-        const { namespace } = tracker;
-        if (this._trackers.has(namespace)) {
-            let warning = `A tracker namespaced ${namespace} was already restored.`;
-            console.warn(warning);
-            return Promise.reject(warning);
-        }
-        const { args, command, name, when } = options;
-        // Add the tracker to the private trackers collection.
-        this._trackers.add(namespace);
-        // Whenever a new widget is added to the tracker, record its name.
-        tracker.widgetAdded.connect((sender, widget) => {
-            const widgetName = name(widget);
-            if (widgetName) {
-                this.add(widget, `${namespace}:${widgetName}`);
-            }
-        }, this);
-        // Whenever a widget is updated, get its new name.
-        tracker.widgetUpdated.connect((sender, widget) => {
-            const widgetName = name(widget);
-            if (widgetName) {
-                let name = `${namespace}:${widgetName}`;
-                Private.nameProperty.set(widget, name);
-                this._widgets.set(name, widget);
-            }
-        });
-        const first = this._first;
-        const promise = tracker
-            .restore({
-            args,
-            command,
-            name,
-            registry: this._registry,
-            state: this._state,
-            when: when ? [first].concat(when) : first
-        })
-            .catch(error => {
-            console.error(error);
-        });
-        this._promises.push(promise);
-        return promise;
-    }
-    /**
-     * Save the layout state for the application.
-     */
-    save(data) {
-        // If there are promises that are unresolved, bail.
-        if (!this._promisesDone) {
-            let warning = 'save() was called prematurely.';
-            console.warn(warning);
-            return Promise.reject(warning);
-        }
-        let dehydrated = {};
-        // Dehydrate main area.
-        dehydrated.main = this._dehydrateMainArea(data.mainArea);
-        // Dehydrate left area.
-        dehydrated.left = this._dehydrateSideArea(data.leftArea);
-        // Dehydrate right area.
-        dehydrated.right = this._dehydrateSideArea(data.rightArea);
-        return this._state.save(KEY, dehydrated);
-    }
-    /**
-     * Dehydrate a main area description into a serializable object.
-     */
-    _dehydrateMainArea(area) {
-        if (!area) {
-            return null;
-        }
-        return Private.serializeMain(area);
-    }
-    /**
-     * Reydrate a serialized main area description object.
-     *
-     * #### Notes
-     * This function consumes data that can become corrupted, so it uses type
-     * coercion to guarantee the dehydrated object is safely processed.
-     */
-    _rehydrateMainArea(area) {
-        if (!area) {
-            return null;
-        }
-        return Private.deserializeMain(area, this._widgets);
-    }
-    /**
-     * Dehydrate a side area description into a serializable object.
-     */
-    _dehydrateSideArea(area) {
-        if (!area) {
-            return null;
-        }
-        let dehydrated = { collapsed: area.collapsed };
-        if (area.currentWidget) {
-            let current = Private.nameProperty.get(area.currentWidget);
-            if (current) {
-                dehydrated.current = current;
-            }
-        }
-        if (area.widgets) {
-            dehydrated.widgets = area.widgets
-                .map(widget => Private.nameProperty.get(widget))
-                .filter(name => !!name);
-        }
-        return dehydrated;
-    }
-    /**
-     * Reydrate a serialized side area description object.
-     *
-     * #### Notes
-     * This function consumes data that can become corrupted, so it uses type
-     * coercion to guarantee the dehydrated object is safely processed.
-     */
-    _rehydrateSideArea(area) {
-        if (!area) {
-            return { collapsed: true, currentWidget: null, widgets: null };
-        }
-        let internal = this._widgets;
-        const collapsed = area.hasOwnProperty('collapsed')
-            ? !!area.collapsed
-            : false;
-        const currentWidget = area.current && internal.has(`${area.current}`)
-            ? internal.get(`${area.current}`)
-            : null;
-        const widgets = !Array.isArray(area.widgets)
-            ? null
-            : area.widgets
-                .map(name => (internal.has(`${name}`) ? internal.get(`${name}`) : null))
-                .filter(widget => !!widget);
-        return {
-            collapsed,
-            currentWidget: currentWidget,
-            widgets: widgets
-        };
-    }
-    /**
-     * Handle a widget disposal.
-     */
-    _onWidgetDisposed(widget) {
-        let name = Private.nameProperty.get(widget);
-        this._widgets.delete(name);
-    }
-}
-exports.LayoutRestorer = LayoutRestorer;
-/*
- * A namespace for private data.
- */
-var Private;
-(function (Private) {
-    /**
-     * An attached property for a widget's ID in the state database.
-     */
-    Private.nameProperty = new properties_1.AttachedProperty({
-        name: 'name',
-        create: owner => ''
-    });
-    /**
-     * Serialize individual areas within the main area.
-     */
-    function serializeArea(area) {
-        if (!area || !area.type) {
-            return null;
-        }
-        if (area.type === 'tab-area') {
-            return {
-                type: 'tab-area',
-                currentIndex: area.currentIndex,
-                widgets: area.widgets
-                    .map(widget => Private.nameProperty.get(widget))
-                    .filter(name => !!name)
-            };
-        }
-        return {
-            type: 'split-area',
-            orientation: area.orientation,
-            sizes: area.sizes,
-            children: area.children.map(serializeArea).filter(area => !!area)
-        };
-    }
-    /**
-     * Return a dehydrated, serializable version of the main dock panel.
-     */
-    function serializeMain(area) {
-        let dehydrated = {
-            dock: (area && area.dock && serializeArea(area.dock.main)) || null
-        };
-        if (area) {
-            dehydrated.mode = area.mode;
-            if (area.currentWidget) {
-                let current = Private.nameProperty.get(area.currentWidget);
-                if (current) {
-                    dehydrated.current = current;
-                }
-            }
-        }
-        return dehydrated;
-    }
-    Private.serializeMain = serializeMain;
-    /**
-     * Deserialize individual areas within the main area.
-     *
-     * #### Notes
-     * Because this data comes from a potentially unreliable foreign source, it is
-     * typed as a `JSONObject`; but the actual expected type is:
-     * `ITabArea | ISplitArea`.
-     *
-     * For fault tolerance, types are manually checked in deserialization.
-     */
-    function deserializeArea(area, names) {
-        if (!area) {
-            return null;
-        }
-        // Because this data is saved to a foreign data source, its type safety is
-        // not guaranteed when it is retrieved, so exhaustive checks are necessary.
-        const type = area.type || 'unknown';
-        if (type === 'unknown' || (type !== 'tab-area' && type !== 'split-area')) {
-            console.warn(`Attempted to deserialize unknown type: ${type}`);
-            return null;
-        }
-        if (type === 'tab-area') {
-            const { currentIndex, widgets } = area;
-            let hydrated = {
-                type: 'tab-area',
-                currentIndex: currentIndex || 0,
-                widgets: (widgets &&
-                    widgets
-                        .map(widget => names.get(widget))
-                        .filter(widget => !!widget)) ||
-                    []
-            };
-            // Make sure the current index is within bounds.
-            if (hydrated.currentIndex > hydrated.widgets.length - 1) {
-                hydrated.currentIndex = 0;
-            }
-            return hydrated;
-        }
-        const { orientation, sizes, children } = area;
-        let hydrated = {
-            type: 'split-area',
-            orientation: orientation,
-            sizes: sizes || [],
-            children: (children &&
-                children
-                    .map(child => deserializeArea(child, names))
-                    .filter(widget => !!widget)) ||
-                []
-        };
-        return hydrated;
-    }
-    /**
-     * Return the hydrated version of the main dock panel, ready to restore.
-     *
-     * #### Notes
-     * Because this data comes from a potentially unreliable foreign source, it is
-     * typed as a `JSONObject`; but the actual expected type is: `IMainArea`.
-     *
-     * For fault tolerance, types are manually checked in deserialization.
-     */
-    function deserializeMain(area, names) {
-        if (!area) {
-            return null;
-        }
-        const name = area.current || null;
-        const dock = area.dock || null;
-        const mode = area.mode || null;
-        return {
-            currentWidget: (name && names.has(name) && names.get(name)) || null,
-            dock: dock ? { main: deserializeArea(dock, names) } : null,
-            mode: mode === 'multiple-document' || mode === 'single-document' ? mode : null
-        };
-    }
-    Private.deserializeMain = deserializeMain;
-})(Private || (Private = {}));
+"use strict";
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const coreutils_1 = require("@phosphor/coreutils");
+const properties_1 = require("@phosphor/properties");
+/* tslint:disable */
+/**
+ * The layout restorer token.
+ */
+exports.ILayoutRestorer = new coreutils_1.Token('@jupyterlab/application:ILayoutRestorer');
+/**
+ * The state database key for restorer data.
+ */
+const KEY = 'layout-restorer:data';
+/**
+ * The default implementation of a layout restorer.
+ *
+ * #### Notes
+ * The lifecycle for state restoration is subtle. The sequence of events is:
+ *
+ * 1. The layout restorer plugin is instantiated and makes a `fetch` call to
+ *    the database that stores the layout restoration data. The `fetch` call
+ *    returns a promise that resolves in step 6, below.
+ *
+ * 2. Other plugins that care about state restoration require the layout
+ *    restorer as a dependency.
+ *
+ * 3. As each load-time plugin initializes (which happens before the lab
+ *    application has `started`), it instructs the layout restorer whether
+ *    the restorer ought to `restore` its state by passing in its tracker.
+ *    Alternatively, a plugin that does not require its own instance tracker
+ *    (because perhaps it only creates a single widget, like a command palette),
+ *    can simply `add` its widget along with a persistent unique name to the
+ *    layout restorer so that its layout state can be restored when the lab
+ *    application restores.
+ *
+ * 4. After all the load-time plugins have finished initializing, the lab
+ *    application `started` promise will resolve. This is the `first`
+ *    promise that the layout restorer waits for. By this point, all of the
+ *    plugins that care about restoration will have instructed the layout
+ *    restorer to `restore` their state.
+ *
+ * 5. The layout restorer will then instruct each plugin's instance tracker
+ *    to restore its state and reinstantiate whichever widgets it wants. The
+ *    tracker returns a promise to the layout restorer that resolves when it
+ *    has completed restoring the tracked widgets it cares about.
+ *
+ * 6. As each instance tracker finishes restoring the widget instances it cares
+ *    about, it resolves the promise that was made to the layout restorer
+ *    (in step 5). After all of the promises that the restorer is awaiting have
+ *    resolved, the restorer then resolves the outstanding `fetch` promise
+ *    (from step 1) and hands off a layout state object to the application
+ *    shell's `restoreLayout` method for restoration.
+ *
+ * 7. Once the application shell has finished restoring the layout, the
+ *    JupyterLab application's `restored` promise is resolved.
+ *
+ * Of particular note are steps 5 and 6: since state restoration of plugins
+ * is accomplished by executing commands, the command that is used to restore
+ * the state of each plugin must return a promise that only resolves when the
+ * widget has been created and added to the plugin's instance tracker.
+ */
+class LayoutRestorer {
+    /**
+     * Create a layout restorer.
+     */
+    constructor(options) {
+        this._firstDone = false;
+        this._promisesDone = false;
+        this._promises = [];
+        this._restored = new coreutils_1.PromiseDelegate();
+        this._trackers = new Set();
+        this._widgets = new Map();
+        this._registry = options.registry;
+        this._state = options.state;
+        this._first = options.first;
+        this._first
+            .then(() => {
+            this._firstDone = true;
+        })
+            .then(() => Promise.all(this._promises))
+            .then(() => {
+            this._promisesDone = true;
+            // Release the tracker set.
+            this._trackers.clear();
+        })
+            .then(() => {
+            this._restored.resolve(void 0);
+        });
+    }
+    /**
+     * A promise resolved when the layout restorer is ready to receive signals.
+     */
+    get restored() {
+        return this._restored.promise;
+    }
+    /**
+     * Add a widget to be tracked by the layout restorer.
+     */
+    add(widget, name) {
+        Private.nameProperty.set(widget, name);
+        this._widgets.set(name, widget);
+        widget.disposed.connect(this._onWidgetDisposed, this);
+    }
+    /**
+     * Fetch the layout state for the application.
+     *
+     * #### Notes
+     * Fetching the layout relies on all widget restoration to be complete, so
+     * calls to `fetch` are guaranteed to return after restoration is complete.
+     */
+    fetch() {
+        const blank = {
+            fresh: true,
+            mainArea: null,
+            leftArea: null,
+            rightArea: null
+        };
+        let layout = this._state.fetch(KEY);
+        return Promise.all([layout, this.restored])
+            .then(([data]) => {
+            if (!data) {
+                return blank;
+            }
+            const { main, left, right } = data;
+            // If any data exists, then this is not a fresh session.
+            const fresh = false;
+            // Rehydrate main area.
+            const mainArea = this._rehydrateMainArea(main);
+            // Rehydrate left area.
+            const leftArea = this._rehydrateSideArea(left);
+            // Rehydrate right area.
+            const rightArea = this._rehydrateSideArea(right);
+            return { fresh, mainArea, leftArea, rightArea };
+        })
+            .catch(() => blank); // Let fetch fail gracefully; return blank slate.
+    }
+    /**
+     * Restore the widgets of a particular instance tracker.
+     *
+     * @param tracker - The instance tracker whose widgets will be restored.
+     *
+     * @param options - The restoration options.
+     */
+    restore(tracker, options) {
+        const warning = 'restore() can only be called before `first` has resolved.';
+        if (this._firstDone) {
+            console.warn(warning);
+            return Promise.reject(warning);
+        }
+        const { namespace } = tracker;
+        if (this._trackers.has(namespace)) {
+            let warning = `A tracker namespaced ${namespace} was already restored.`;
+            console.warn(warning);
+            return Promise.reject(warning);
+        }
+        const { args, command, name, when } = options;
+        // Add the tracker to the private trackers collection.
+        this._trackers.add(namespace);
+        // Whenever a new widget is added to the tracker, record its name.
+        tracker.widgetAdded.connect((sender, widget) => {
+            const widgetName = name(widget);
+            if (widgetName) {
+                this.add(widget, `${namespace}:${widgetName}`);
+            }
+        }, this);
+        // Whenever a widget is updated, get its new name.
+        tracker.widgetUpdated.connect((sender, widget) => {
+            const widgetName = name(widget);
+            if (widgetName) {
+                let name = `${namespace}:${widgetName}`;
+                Private.nameProperty.set(widget, name);
+                this._widgets.set(name, widget);
+            }
+        });
+        const first = this._first;
+        const promise = tracker
+            .restore({
+            args,
+            command,
+            name,
+            registry: this._registry,
+            state: this._state,
+            when: when ? [first].concat(when) : first
+        })
+            .catch(error => {
+            console.error(error);
+        });
+        this._promises.push(promise);
+        return promise;
+    }
+    /**
+     * Save the layout state for the application.
+     */
+    save(data) {
+        // If there are promises that are unresolved, bail.
+        if (!this._promisesDone) {
+            let warning = 'save() was called prematurely.';
+            console.warn(warning);
+            return Promise.reject(warning);
+        }
+        let dehydrated = {};
+        // Dehydrate main area.
+        dehydrated.main = this._dehydrateMainArea(data.mainArea);
+        // Dehydrate left area.
+        dehydrated.left = this._dehydrateSideArea(data.leftArea);
+        // Dehydrate right area.
+        dehydrated.right = this._dehydrateSideArea(data.rightArea);
+        return this._state.save(KEY, dehydrated);
+    }
+    /**
+     * Dehydrate a main area description into a serializable object.
+     */
+    _dehydrateMainArea(area) {
+        if (!area) {
+            return null;
+        }
+        return Private.serializeMain(area);
+    }
+    /**
+     * Reydrate a serialized main area description object.
+     *
+     * #### Notes
+     * This function consumes data that can become corrupted, so it uses type
+     * coercion to guarantee the dehydrated object is safely processed.
+     */
+    _rehydrateMainArea(area) {
+        if (!area) {
+            return null;
+        }
+        return Private.deserializeMain(area, this._widgets);
+    }
+    /**
+     * Dehydrate a side area description into a serializable object.
+     */
+    _dehydrateSideArea(area) {
+        if (!area) {
+            return null;
+        }
+        let dehydrated = { collapsed: area.collapsed };
+        if (area.currentWidget) {
+            let current = Private.nameProperty.get(area.currentWidget);
+            if (current) {
+                dehydrated.current = current;
+            }
+        }
+        if (area.widgets) {
+            dehydrated.widgets = area.widgets
+                .map(widget => Private.nameProperty.get(widget))
+                .filter(name => !!name);
+        }
+        return dehydrated;
+    }
+    /**
+     * Reydrate a serialized side area description object.
+     *
+     * #### Notes
+     * This function consumes data that can become corrupted, so it uses type
+     * coercion to guarantee the dehydrated object is safely processed.
+     */
+    _rehydrateSideArea(area) {
+        if (!area) {
+            return { collapsed: true, currentWidget: null, widgets: null };
+        }
+        let internal = this._widgets;
+        const collapsed = area.hasOwnProperty('collapsed')
+            ? !!area.collapsed
+            : false;
+        const currentWidget = area.current && internal.has(`${area.current}`)
+            ? internal.get(`${area.current}`)
+            : null;
+        const widgets = !Array.isArray(area.widgets)
+            ? null
+            : area.widgets
+                .map(name => (internal.has(`${name}`) ? internal.get(`${name}`) : null))
+                .filter(widget => !!widget);
+        return {
+            collapsed,
+            currentWidget: currentWidget,
+            widgets: widgets
+        };
+    }
+    /**
+     * Handle a widget disposal.
+     */
+    _onWidgetDisposed(widget) {
+        let name = Private.nameProperty.get(widget);
+        this._widgets.delete(name);
+    }
+}
+exports.LayoutRestorer = LayoutRestorer;
+/*
+ * A namespace for private data.
+ */
+var Private;
+(function (Private) {
+    /**
+     * An attached property for a widget's ID in the state database.
+     */
+    Private.nameProperty = new properties_1.AttachedProperty({
+        name: 'name',
+        create: owner => ''
+    });
+    /**
+     * Serialize individual areas within the main area.
+     */
+    function serializeArea(area) {
+        if (!area || !area.type) {
+            return null;
+        }
+        if (area.type === 'tab-area') {
+            return {
+                type: 'tab-area',
+                currentIndex: area.currentIndex,
+                widgets: area.widgets
+                    .map(widget => Private.nameProperty.get(widget))
+                    .filter(name => !!name)
+            };
+        }
+        return {
+            type: 'split-area',
+            orientation: area.orientation,
+            sizes: area.sizes,
+            children: area.children.map(serializeArea).filter(area => !!area)
+        };
+    }
+    /**
+     * Return a dehydrated, serializable version of the main dock panel.
+     */
+    function serializeMain(area) {
+        let dehydrated = {
+            dock: (area && area.dock && serializeArea(area.dock.main)) || null
+        };
+        if (area) {
+            dehydrated.mode = area.mode;
+            if (area.currentWidget) {
+                let current = Private.nameProperty.get(area.currentWidget);
+                if (current) {
+                    dehydrated.current = current;
+                }
+            }
+        }
+        return dehydrated;
+    }
+    Private.serializeMain = serializeMain;
+    /**
+     * Deserialize individual areas within the main area.
+     *
+     * #### Notes
+     * Because this data comes from a potentially unreliable foreign source, it is
+     * typed as a `JSONObject`; but the actual expected type is:
+     * `ITabArea | ISplitArea`.
+     *
+     * For fault tolerance, types are manually checked in deserialization.
+     */
+    function deserializeArea(area, names) {
+        if (!area) {
+            return null;
+        }
+        // Because this data is saved to a foreign data source, its type safety is
+        // not guaranteed when it is retrieved, so exhaustive checks are necessary.
+        const type = area.type || 'unknown';
+        if (type === 'unknown' || (type !== 'tab-area' && type !== 'split-area')) {
+            console.warn(`Attempted to deserialize unknown type: ${type}`);
+            return null;
+        }
+        if (type === 'tab-area') {
+            const { currentIndex, widgets } = area;
+            let hydrated = {
+                type: 'tab-area',
+                currentIndex: currentIndex || 0,
+                widgets: (widgets &&
+                    widgets
+                        .map(widget => names.get(widget))
+                        .filter(widget => !!widget)) ||
+                    []
+            };
+            // Make sure the current index is within bounds.
+            if (hydrated.currentIndex > hydrated.widgets.length - 1) {
+                hydrated.currentIndex = 0;
+            }
+            return hydrated;
+        }
+        const { orientation, sizes, children } = area;
+        let hydrated = {
+            type: 'split-area',
+            orientation: orientation,
+            sizes: sizes || [],
+            children: (children &&
+                children
+                    .map(child => deserializeArea(child, names))
+                    .filter(widget => !!widget)) ||
+                []
+        };
+        return hydrated;
+    }
+    /**
+     * Return the hydrated version of the main dock panel, ready to restore.
+     *
+     * #### Notes
+     * Because this data comes from a potentially unreliable foreign source, it is
+     * typed as a `JSONObject`; but the actual expected type is: `IMainArea`.
+     *
+     * For fault tolerance, types are manually checked in deserialization.
+     */
+    function deserializeMain(area, names) {
+        if (!area) {
+            return null;
+        }
+        const name = area.current || null;
+        const dock = area.dock || null;
+        const mode = area.mode || null;
+        return {
+            currentWidget: (name && names.has(name) && names.get(name)) || null,
+            dock: dock ? { main: deserializeArea(dock, names) } : null,
+            mode: mode === 'multiple-document' || mode === 'single-document' ? mode : null
+        };
+    }
+    Private.deserializeMain = deserializeMain;
+})(Private || (Private = {}));