Update docs

docs/source/developer/css.rst

@@ -112,7 +112,7 @@ CSS class naming conventions
 We have a fairly formal method for naming our CSS classes.
 
 First, CSS class names are associated with TypeScript classes that
-extend ``phosphor.Widget``:
+extend ``lumino.Widget``:
 
 The ``.node`` of each such widget should have a CSS class that matches
 the name of the TypeScript class:

docs/source/developer/extension_dev.rst

@@ -101,19 +101,19 @@ In JupyterLab, the application shell consists of:
 -  A ``bottom`` area for things like status bars.
 -  A ``header`` area for custom elements.
 
-Phosphor
+Lumino
 ~~~~~~~~
 
-The Phosphor library is used as the underlying architecture of
+The Lumino library is used as the underlying architecture of
 JupyterLab and provides many of the low level primitives and widget
-structure used in the application. Phosphor provides a rich set of
+structure used in the application. Lumino provides a rich set of
 widgets for developing desktop-like applications in the browser, as well
 as patterns and objects for writing clean, well-abstracted code. The
-widgets in the application are primarily **Phosphor widgets**, and
-Phosphor concepts, like message passing and signals, are used
-throughout. **Phosphor messages** are a *many-to-one* interaction that
+widgets in the application are primarily **Lumino widgets**, and
+Lumino concepts, like message passing and signals, are used
+throughout. **Lumino messages** are a *many-to-one* interaction that
 enables information like resize events to flow through the widget
-hierarchy in the application. **Phosphor signals** are a *one-to-many*
+hierarchy in the application. **Lumino signals** are a *one-to-many*
 interaction that enable listeners to react to changes in an observed
 object.
 
@@ -579,13 +579,13 @@ Context Menus
 ^^^^^^^^^^^^^
 
 JupyterLab has an application-wide context menu available as
-``app.contextMenu``. See the Phosphor
+``app.contextMenu``. See the Lumino
 `docs <https://jupyterlab.github.io/lumino/widgets/interfaces/contextmenu.iitemoptions.html>`__
 for the item creation options. If you wish to preempt the
 application context menu, you can use a 'contextmenu' event listener and
 call ``event.stopPropagation`` to prevent the application context menu
 handler from being called (it is listening in the bubble phase on the
-``document``). At this point you could show your own Phosphor
+``document``). At this point you could show your own Lumino
 `contextMenu <https://jupyterlab.github.io/lumino/widgets/classes/contextmenu.html>`__,
 or simply stop propagation and let the system context menu be shown.
 This would look something like the following in a ``Widget`` subclass:

docs/source/developer/extension_points.rst

@@ -11,7 +11,7 @@ This is intended to be a guide for some of JupyterLab's most commonly-used exten
 However, it is not an exhaustive account of how to extend the application components,
 and more detailed descriptions of their public APIs may be found in the
 `JupyterLab <http://jupyterlab.github.io/jupyterlab/index.html>`__ and
-`Phosphor <http://phosphorjs.github.io/docs.html>`__ API documentation.
+`Lumino <http://jupyterlab.github.io/lumino/index.html>`__ API documentation.
 
 .. contents:: Table of contents
     :local:
@@ -110,7 +110,7 @@ Adding a New Menu
 ^^^^^^^^^^^^^^^^^
 
 To add a new menu to the menu bar, you need to create a new
-`Phosphor menu <https://jupyterlab.github.io/lumino/widgets/classes/menu.html>`__.
+`Lumino menu <https://jupyterlab.github.io/lumino/widgets/classes/menu.html>`__.
 
 You can then add commands to the menu in a similar way to the command palette,
 and add that menu to the main menu bar:
@@ -299,7 +299,7 @@ Left/Right Areas
 The left and right areas of JupyterLab are intended to host more persistent user interface
 elements than the main area. That being said, extension authors are free to add whatever
 components they like to these areas. The outermost-level of the object that you add is expected
-to be a Phosphor ``Widget``, but that can host any content you like (such as React components).
+to be a Lumino ``Widget``, but that can host any content you like (such as React components).
 
 As an example, the following code executes an application command to a terminal widget
 and then adds the terminal to the right area:
@@ -317,7 +317,7 @@ Status Bar
 ~~~~~~~~~~
 
 JupyterLab's status bar is intended to show small pieces of contextual information.
-Like the left and right areas, it only expects a Phosphor ``Widget``,
+Like the left and right areas, it only expects a Lumino ``Widget``,
 which might contain any kind of content. Since the status bar has limited space,
 you should endeavor to only add small widgets to it.
 

docs/source/developer/extension_tutorial.rst

@@ -216,15 +216,15 @@ you in JupyterLab. For your first addition, you're going to add a
 tab panel when invoked.
 
 Fire up your favorite text editor and open the ``src/index.ts`` file in
-your extension project. Change the import at the top of the file to get 
+your extension project. Change the import at the top of the file to get
 a reference to the command palette interface and the Jupyter front end.
 
 .. code:: typescript
-    
+
     import {
       JupyterFrontEnd, JupyterFrontEndPlugin
     } from '@jupyterlab/application';
-    
+
     import {
       ICommandPalette
     } from '@jupyterlab/apputils';
@@ -300,13 +300,13 @@ Now return to your editor. Modify the imports at the top of the file to add a fe
 
     import {
       Widget
-    } from '@phosphor/widgets';
+    } from '@lumino/widgets';
 
 Install this new dependency as well:
 
 .. code:: bash
 
-    jlpm add @phosphor/widgets
+    jlpm add @lumino/widgets
 
 
 Then modify the ``activate`` function again so that it has the following
@@ -346,7 +346,7 @@ The first new block of code creates a ``MainAreaWidget`` instance with an empty
 content ``Widget`` as its child. It also assigns the main area widget a unique
 ID, gives it a label that will appear as its tab title, and makes the tab
 closable by the user.
-The second block of code adds a new command with id ``apod:open`` and label *Random Astronomy Picture* 
+The second block of code adds a new command with id ``apod:open`` and label *Random Astronomy Picture*
 to JupyterLab. When the command executes,
 it attaches the widget to the main display area if it is not already
 present and then makes it the active tab. The last new line of code uses the command id to add
@@ -591,13 +591,13 @@ Add the following additional import to the top of the file.
 
     import {
       Message
-    } from '@phosphor/messaging';
+    } from '@lumino/messaging';
 
 Install this dependency:
 
 .. code:: bash
 
-    jlpm add @phosphor/messaging
+    jlpm add @lumino/messaging
 
 
 Then add the class just below the import statements in the ``index.ts``
@@ -777,17 +777,17 @@ entire list of import statements looks like the following:
 
     import {
       Message
-    } from '@phosphor/messaging';
+    } from '@lumino/messaging';
 
     import {
       Widget
-    } from '@phosphor/widgets';
+    } from '@lumino/widgets';
 
 Install this dependency:
 
 .. code:: bash
 
-    jlpm add @phosphor/coreutils
+    jlpm add @lumino/coreutils
 
 Then add the ``ILayoutRestorer`` interface to the ``JupyterFrontEndPlugin``
 definition. This addition passes the global ``LayoutRestorer`` as the

docs/source/developer/notebook.rst

@@ -165,7 +165,7 @@ released npm packages, not the development versions.
 
 ::
 
-    npm install --save @jupyterlab/notebook @jupyterlab/application @jupyterlab/apputils @jupyterlab/docregistry @phosphor/disposable
+    npm install --save @jupyterlab/notebook @jupyterlab/application @jupyterlab/apputils @jupyterlab/docregistry @lumino/disposable
 
 Copy the following to ``src/index.ts``:
 
@@ -173,7 +173,7 @@ Copy the following to ``src/index.ts``:
 
     import {
       IDisposable, DisposableDelegate
-    } from '@phosphor/disposable';
+    } from '@lumino/disposable';
 
     import {
       JupyterFrontEnd, JupyterFrontEndPlugin
@@ -256,9 +256,9 @@ The *ipywidgets* third party extension
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This discussion will be a bit confusing since we've been using the term
-*widget* to refer to *phosphor widgets*. In the discussion below,
+*widget* to refer to *lumino widgets*. In the discussion below,
 *ipython widgets* will be referred to as *ipywidgets*. There is no
-intrinsic relation between *phosphor widgets* and *ipython widgets*.
+intrinsic relation between *lumino widgets* and *ipython widgets*.
 
 The *ipywidgets* extension registers a factory for a notebook *widget*
 extension using the `Document
@@ -277,7 +277,7 @@ a ``display_data`` output is sent to the browser with the ipywidget
 model id. The renderer registered in that notebook's rendermime is asked
 to render the output. The renderer asks the ipywidget manager instance
 to render the corresponding model, which returns a JavaScript promise.
-The renderer creates a container *phosphor widget* which it hands back
+The renderer creates a container *lumino widget* which it hands back
 synchronously to the OutputArea, and then fills the container with the
 rendered *ipywidget* when the promise resolves.
 

docs/source/developer/terminology.rst

@@ -15,7 +15,7 @@ Terms
    be used to extend JupyterLab's functionality.
 -  *Plugin* - An object that provides a service and or extends the
    application.
--  *Phosphor* - The JavaScript library that provides the foundation of
+-  *Lumino* - The JavaScript library that provides the foundation of
    JupyterLab, enabling desktop-like applications in the browser.
 -  *Standalone example* - An example in the ``examples/`` directory that
    demonstrates the usage of one or more components of JupyterLab.

docs/source/developer/virtualdom.create.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 
-import { Widget } from '@phosphor/widgets';
+import { Widget } from '@lumino/widgets';
 import { ReactWidget } from '@jupyterlab/apputils';
 
 function MyComponent() {

docs/source/developer/virtualdom.reactwidget.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 
-import { Widget } from '@phosphor/widgets';
+import { Widget } from '@lumino/widgets';
 import { ReactWidget } from '@jupyterlab/apputils';
 
 function MyComponent() {

docs/source/developer/virtualdom.rst

@@ -4,7 +4,7 @@ React
 -----
 
 
-Many JupyterLab APIs require `Phosphor <https://phosphorjs.github.io/>`__
+Many JupyterLab APIs require `Lumino`
 `Widgets <https://jupyterlab.github.io/lumino/widgets/classes/widget.html>`__
 which have some additional features over native DOM elements, including:
 
@@ -12,7 +12,7 @@ which have some additional features over native DOM elements, including:
 -  Lifecycle events (``onBeforeDetach``, ``onAfterAttach``, etc.).
 -  Both CSS-based and absolutely positioned layouts.
 
-We support wrapping React components to turn them into Phosphor
+We support wrapping React components to turn them into Lumino
 widgets using the ``ReactWidget`` class from ``@jupyterlab/apputils``:
 
 .. literalinclude:: virtualdom.create.tsx
@@ -20,10 +20,10 @@ widgets using the ``ReactWidget`` class from ``@jupyterlab/apputils``:
 
 
 Here we use the ``create`` static method to transform a React element
-into a Phosphor widget. Whenever the widget is mounted, the React
+into a Lumino widget. Whenever the widget is mounted, the React
 element will be rendered on the page.
 
-If you need to handle other life cycle events on the Phosphor widget
+If you need to handle other life cycle events on the Lumino widget
 or add other methods to it, you can subbclass ``ReactWidget`` and
 override the ``render`` method to return a React element:
 
@@ -32,7 +32,7 @@ override the ``render`` method to return a React element:
    :force:
 
 
-We use Phosphor `Signals <https://jupyterlab.github.io/lumino/signaling/interfaces/isignal.html>`__ to represent
+We use Lumino `Signals <https://jupyterlab.github.io/lumino/signaling/interfaces/isignal.html>`__ to represent
 data that changes over time in JupyterLab.
 To have your React element change in response to a signal event, use the ``UseSignal`` component from ``@jupyterlab/apputils``,
 which implements the `"render props" <https://reactjs.org/docs/render-props.html>`__:
@@ -46,7 +46,7 @@ The `running component <https://github.com/jupyterlab/jupyterlab/blob/f2e0cde0e7
 and the ``createSearchOverlay`` function in the `search overlay <https://github.com/jupyterlab/jupyterlab/blob/f2e0cde0e7c960dc82fd9b010fcd3dbd9e9b43d0/packages/documentsearch/src/searchoverlay.tsx#L440-L457>`__
 use both of these features and serve as a good reference for best practices.
 
-We currently do not have a way of embedding Phosphor widgets inside of React components. If you find yourself trying to do this, we would recommend either converting the Phosphor widget to a React component or using a Phosphor widget for the outer layer component.
+We currently do not have a way of embedding Lumino widgets inside of React components. If you find yourself trying to do this, we would recommend either converting the Lumino widget to a React component or using a Lumino widget for the outer layer component.
 
 We follow the `React documentation <https://reactjs.org/docs/thinking-in-react.html>`__ and
 `"React & Redux in TypeScript - Static Typing Guide" <https://github.com/piotrwitek/react-redux-typescript-guide#readme>`__

docs/source/developer/virtualdom.usesignal.tsx

@@ -2,9 +2,9 @@ import * as React from 'react';
 
 import { ReactWidget, UseSignal } from '@jupyterlab/apputils';
 
-import { ISignal, Signal } from '@phosphor/signaling';
+import { ISignal, Signal } from '@lumino/signaling';
 
-import { Widget } from '@phosphor/widgets';
+import { Widget } from '@lumino/widgets';
 
 function MyComponent() {
   return <div>My Widget</div>;