@jupyterlab/notebook

constructor

constructor(widget: Notebook, translator?: ITranslator);

• Construct a new cell type switcher.

property handleChange

handleChange: (event: React.ChangeEvent<HTMLSelectElement>) => void;

• Handle change events for the HTMLSelect component.

property handleKeyDown

handleKeyDown: (event: React.KeyboardEvent) => void;

• Handle keydown events for the HTMLSelect component.

method render

render: () => JSX.Element;

constructor

constructor(translator?: ITranslator);

• Construct a new CommandEdit status item.

property translator

protected translator: ITranslator;

method render

render: () => JSX.Element | null;

• Render the CommandEdit status item.

constructor

constructor(translator?: ITranslator, showProgress?: boolean);

• Construct the kernel status widget.

method render

render: () => JSX.Element | null;

• Render the execution status item.

constructor

constructor(content: KernelMessage.IExecuteReplyMsg);

• Construct the kernel error.

property errorName

readonly errorName: string;

• Exception name

property errorValue

readonly errorValue: string;

• Exception value

property traceback

readonly traceback: string[];

• Traceback

constructor

constructor(options: Notebook.IOptions);

• Construct a notebook widget.

property activeCell

readonly activeCell: any;

• Get the active cell widget.

  #### Notes This is a cell or null if there is no active cell.

property activeCellChanged

readonly activeCellChanged: ISignal<this, Cell>;

• A signal emitted when the active cell changes.

  #### Notes This can be due to the active index changing or the cell at the active index changing.

property activeCellIndex

activeCellIndex: number;

• The active cell index of the notebook.

  #### Notes The index will be clamped to the bounds of the notebook cells.

property lastClipboardInteraction

lastClipboardInteraction: 'copy' | 'cut' | 'paste';

property mode

mode: NotebookMode;

• The interactivity mode of the notebook.

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state of the notebook changes.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the state of the notebook changes.

method deselect

deselect: (widget: Cell) => void;

• Deselect a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method deselectAll

deselectAll: () => void;

• Deselect all of the cells.

method dispose

dispose: () => void;

• Dispose of the resources held by the widget.

method extendContiguousSelectionTo

extendContiguousSelectionTo: (index: number) => void;

• Move the head of an existing contiguous selection to extend the selection.

  Parameter index

  The new head of the existing selection.

  #### Notes If there is no existing selection, the active cell is considered an existing one-cell selection.

  If the new selection is a single cell, that cell becomes the active cell and all cells are deselected.

  There is no change if there are no cells (i.e., activeCellIndex is -1).

method getContiguousSelection

getContiguousSelection: () =>
    | { head: number; anchor: number }
    | { head: null; anchor: null };

• Get the head and anchor of a contiguous cell selection.

  The head of a contiguous selection is always the active cell.

  If there are no cells selected, {head: null, anchor: null} is returned.

  Throws an error if the currently selected cells do not form a contiguous selection.

method handleEvent

handleEvent: (event: Event) => void;

• Handle the DOM events for the widget.

  Parameter event

  The DOM event sent to the widget.

  #### Notes This method implements the DOM EventListener interface and is called in response to events on the notebook panel's node. It should not be called directly by user code.

method isSelected

isSelected: (widget: Cell) => boolean;

• Whether a cell is selected.

method isSelectedOrActive

isSelectedOrActive: (widget: Cell) => boolean;

• Whether a cell is selected or is the active cell.

method onActivateRequest

protected onActivateRequest: (msg: Message) => void;

• Handle 'activate-request' messages.

method onAfterAttach

protected onAfterAttach: (msg: Message) => void;

• Handle after-attach messages for the widget.

method onAfterShow

protected onAfterShow: (msg: Message) => void;

• A message handler invoked on an 'after-show' message.

method onBeforeDetach

protected onBeforeDetach: (msg: Message) => void;

• Handle before-detach messages for the widget.

method onBeforeHide

protected onBeforeHide: (msg: Message) => void;

• A message handler invoked on an 'before-hide' message.

method onCellInserted

protected onCellInserted: (index: number, cell: Cell) => void;

• Handle a cell being inserted.

method onCellMoved

protected onCellMoved: (fromIndex: number, toIndex: number) => void;

• Handle a cell being moved.

method onCellRemoved

protected onCellRemoved: (index: number, cell: Cell) => void;

• Handle a cell being removed.

method onModelChanged

protected onModelChanged: (
    oldValue: INotebookModel,
    newValue: INotebookModel
) => void;

• Handle a new model.

method onResize

protected onResize: (msg: Widget.ResizeMessage) => void;

• A message handler invoked on a 'resize' message.

method onUpdateRequest

protected onUpdateRequest: (msg: Message) => void;

• Handle update-request messages sent to the widget.

method scrollToCell

scrollToCell: (cell: Cell) => void;

• Scroll so that the given cell is in view. Selects and activates cell.

  Parameter cell

  A cell in the notebook widget.

method scrollToPosition

scrollToPosition: (position: number, threshold?: number) => void;

• Scroll so that the given position is centered.

  Parameter position

  The vertical position in the notebook widget.

  Parameter threshold

  An optional threshold for the scroll (0-50, defaults to 25).

  #### Notes If the position is within the threshold percentage of the widget height, measured from the center of the widget, the scroll position will not be changed. A threshold of 0 means we will always scroll so the position is centered, and a threshold of 50 means scrolling only happens if position is outside the current window.

method select

select: (widget: Cell) => void;

• Select a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method setFragment

setFragment: (fragment: string) => void;

• Set URI fragment identifier.

property executed

static readonly executed: ISignal<
    any,
    {
        notebook: Notebook;
        cell: Cell;
        success: boolean;
        error?: KernelError | null;
    }
>;

• A signal that emits whenever a cell completes execution.

property executionScheduled

static readonly executionScheduled: ISignal<
    any,
    { notebook: Notebook; cell: Cell }
>;

• A signal that emits whenever a cell execution is scheduled.

property selectionExecuted

static readonly selectionExecuted: ISignal<
    any,
    { notebook: Notebook; lastCell: Cell }
>;

• A signal that emits whenever a cell execution is scheduled.

constructor

constructor(options?: NotebookModel.IOptions);

• Construct a new notebook model.

property cells

readonly cells: IObservableUndoableList<ICellModel>;

• Get the observable list of notebook cells.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentChanged

readonly contentChanged: ISignal<this, void>;

• A signal emitted when the document content changes.

property contentFactory

readonly contentFactory: NotebookModel.IContentFactory;

• The cell model factory for the notebook.

property defaultKernelLanguage

readonly defaultKernelLanguage: string;

• The default kernel language of the document.

property defaultKernelName

readonly defaultKernelName: string;

• The default kernel name of the document.

property deletedCells

readonly deletedCells: string[];

• A list of deleted cells for the notebook..

property dirty

dirty: boolean;

• The dirty state of the document.

property isDisposed

readonly isDisposed: boolean;

• Whether the model is disposed.

property isInitialized

readonly isInitialized: boolean;

• If the model is initialized or not.

property metadata

readonly metadata: IObservableJSON;

• The metadata associated with the notebook.

property modelDB

readonly modelDB: IModelDB;

• The underlying IModelDB instance in which model data is stored.

property nbformat

readonly nbformat: number;

• The major version number of the nbformat.

property nbformatMinor

readonly nbformatMinor: number;

• The minor version number of the nbformat.

property readOnly

readOnly: boolean;

• The read only state of the document.

property sharedModel

readonly sharedModel: models.ISharedNotebook;

• The shared notebook model.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the document state changes.

method dispose

dispose: () => void;

• Dispose of the resources held by the model.

method fromJSON

fromJSON: (value: nbformat.INotebookContent) => void;

• Deserialize the model from JSON.

  #### Notes Should emit a [contentChanged] signal.

method fromString

fromString: (value: string) => void;

• Deserialize the model from a string.

  #### Notes Should emit a [contentChanged] signal.

method initialize

initialize: () => void;

• Initialize the model with its current state.

  # Notes Adds an empty code cell if the model is empty and clears undo state.

method toJSON

toJSON: () => nbformat.INotebookContent;

• Serialize the model to JSON.

method toString

toString: () => string;

• Serialize the model to a string.

method triggerContentChange

protected triggerContentChange: () => void;

• Trigger a content changed signal.

method triggerStateChange

protected triggerStateChange: (args: IChangedArgs<any>) => void;

• Trigger a state change signal.

constructor

constructor(options: NotebookModelFactory.IOptions);

• Construct a new notebook model factory.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentFactory

readonly contentFactory: NotebookModel.IContentFactory;

• The content model factory used by the NotebookModelFactory.

property contentType

readonly contentType: Contents.ContentType;

• The content type of the file.

property fileFormat

readonly fileFormat: Contents.FileFormat;

• The format of the file.

property isDisposed

readonly isDisposed: boolean;

• Get whether the model factory has been disposed.

property name

readonly name: string;

• The name of the model.

method createNew

createNew: (
    languagePreference?: string,
    modelDB?: IModelDB,
    isInitialized?: boolean,
    collaborationEnabled?: boolean
) => INotebookModel;

• Create a new model for a given path.

  Parameter languagePreference

  An optional kernel language preference.

  Parameter modelDB

  An optional model storage.

  Parameter isInitialized

  Whether the model is initialized or not.

  Parameter collaborationEnabled

  Whether collaboration is enabled at the application level or not (default false).

  Returns

  A new document model.

method dispose

dispose: () => void;

• Dispose of the model factory.

method preferredLanguage

preferredLanguage: (path: string) => string;

• Get the preferred kernel language given a path.

constructor

constructor(options: DocumentWidget.IOptions<Notebook, INotebookModel>);

• Construct a new notebook panel.

property model

readonly model: INotebookModel;

• The model for the widget.

property sessionContext

readonly sessionContext: ISessionContext;

• The session context used by the panel.

property translator

translator: ITranslator;

method [Printing.symbol]

[Printing.symbol]: () => () => Promise<void>;

• Prints the notebook by converting to HTML with nbconvert.

method dispose

dispose: () => void;

• Dispose of the resources used by the widget.

method setConfig

setConfig: (config: NotebookPanel.IConfig) => void;

• Update the options for the current notebook panel.

  Parameter config

  new options to set

method setFragment

setFragment: (fragment: string) => void;

• Set URI fragment identifier.

constructor

constructor(options: NotebookTools.IOptions);

• Construct a new NotebookTools object.

property activeCell

readonly activeCell: any;

• The active cell widget.

property activeNotebookPanel

readonly activeNotebookPanel: NotebookPanel;

• The current notebook.

property selectedCells

readonly selectedCells: Cell[];

• The currently selected cells.

property translator

translator: ITranslator;

method addItem

addItem: (options: NotebookTools.IAddOptions) => void;

• Add a cell tool item.

property activeCell

readonly activeCell: any;

• The currently focused cell.

  #### Notes This is a read-only property. If there is no cell with the focus, then this value is null.

property activeCellChanged

readonly activeCellChanged: ISignal<this, any>;

• A signal emitted when the current active cell changes.

  #### Notes If there is no cell with the focus, then null will be emitted.

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state changes.

method add

add: (panel: NotebookPanel) => Promise<void>;

• Add a new notebook panel to the tracker.

  Parameter panel

  The notebook panel being added.

method dispose

dispose: () => void;

• Dispose of the resources held by the tracker.

method onCurrentChanged

protected onCurrentChanged: (widget: NotebookPanel) => void;

• Handle the current change event.

constructor

constructor(translator?: ITranslator);

• Construct a new status item.

property translator

translator: ITranslator;

method render

render: () => JSX.Element | null;

• Render the NotebookTrust status item.

constructor

constructor(options: NotebookWidgetFactory.IOptions<NotebookPanel>);

• Construct a new notebook widget factory.

  Parameter options

  The options used to construct the factory.

property contentFactory

readonly contentFactory: NotebookPanel.IContentFactory;

• The content factory used by the widget factory.

property editorConfig

editorConfig: StaticNotebook.IEditorConfig;

• A configuration object for cell editor settings.

property mimeTypeService

readonly mimeTypeService: IEditorMimeTypeService;

• The service used to look up mime types.

property notebookConfig

notebookConfig: StaticNotebook.INotebookConfig;

• A configuration object for notebook settings.

property rendermime

readonly rendermime: IRenderMimeRegistry;

method createNewWidget

protected createNewWidget: (
    context: DocumentRegistry.IContext<INotebookModel>,
    source?: NotebookPanel
) => NotebookPanel;

• Create a new widget.

  #### Notes The factory will start the appropriate kernel.

method defaultToolbarFactory

protected defaultToolbarFactory: (
    widget: NotebookPanel
) => DocumentRegistry.IToolbarItem[];

• Default factory for toolbar items to be added after the widget is created.

constructor

constructor(options: StaticNotebook.IOptions);

• Construct a notebook widget.

property codeMimetype

readonly codeMimetype: string;

• Get the mimetype for code cells.

property contentFactory

readonly contentFactory: StaticNotebook.IContentFactory;

• The cell factory used by the widget.

property editorConfig

editorConfig: StaticNotebook.IEditorConfig;

• A configuration object for cell editor settings.

property fullyRendered

readonly fullyRendered: ISignal<this, boolean>;

• A signal emitted when the notebook is fully rendered.

property model

model: INotebookModel;

• The model for the widget.

property modelChanged

readonly modelChanged: ISignal<this, void>;

• A signal emitted when the model of the notebook changes.

property modelContentChanged

readonly modelContentChanged: ISignal<this, void>;

• A signal emitted when the model content changes.

  #### Notes This is a convenience signal that follows the current model.

property notebookConfig

notebookConfig: StaticNotebook.INotebookConfig;

• A configuration object for notebook settings.

property placeholderCellRendered

readonly placeholderCellRendered: ISignal<this, Cell>;

• A signal emitted when the a placeholder cell is rendered.

property remainingCellToRenderCount

readonly remainingCellToRenderCount: number;

property renderingLayout

renderingLayout: RenderingLayout;

property renderingLayoutChanged

readonly renderingLayoutChanged: ISignal<this, RenderingLayout>;

• A signal emitted when the rendering layout of the notebook changes.

property rendermime

readonly rendermime: IRenderMimeRegistry;

• The Rendermime instance used by the widget.

property translator

readonly translator: ITranslator;

• Translator to be used by cell renderers

property widgets

readonly widgets: readonly Cell[];

• A read-only sequence of the widgets in the notebook.

method dispose

dispose: () => void;

• Dispose of the resources held by the widget.

method onCellInserted

protected onCellInserted: (index: number, cell: Cell) => void;

• Handle a cell being inserted.

  The default implementation is a no-op

method onCellMoved

protected onCellMoved: (fromIndex: number, toIndex: number) => void;

• Handle a cell being moved.

  The default implementation is a no-op

method onCellRemoved

protected onCellRemoved: (index: number, cell: Cell) => void;

• Handle a cell being removed.

  The default implementation is a no-op

method onMetadataChanged

protected onMetadataChanged: (
    sender: IObservableMap<any>,
    args: IObservableMap.IChangedArgs<ReadonlyPartialJSONValue>
) => void;

• Handle changes to the notebook model metadata.

  #### Notes The default implementation updates the mimetypes of the code cells when the language_info metadata changes.

method onModelChanged

protected onModelChanged: (
    oldValue: INotebookModel | null,
    newValue: INotebookModel | null
) => void;

• Handle a new model.

  #### Notes This method is called after the model change has been handled internally and before the modelChanged signal is emitted. The default implementation is a no-op.

method onModelContentChanged

protected onModelContentChanged: (model: INotebookModel, args: void) => void;

• Handle changes to the notebook model content.

  #### Notes The default implementation emits the modelContentChanged signal.

property cells

readonly cells: IObservableUndoableList<ICellModel>;

• The list of cells in the notebook.

property contentFactory

readonly contentFactory: NotebookModel.IContentFactory;

• The cell model factory for the notebook.

property deletedCells

readonly deletedCells: string[];

• The array of deleted cells since the notebook was last run.

property isInitialized

isInitialized: boolean;

• If the model is initialized or not.

property metadata

readonly metadata: IObservableJSON;

• The metadata associated with the notebook.

property nbformat

readonly nbformat: number;

• The major version number of the nbformat.

property nbformatMinor

readonly nbformatMinor: number;

• The minor version number of the nbformat.

property sharedModel

readonly sharedModel: models.ISharedNotebook;

property activeCell

activeCell: Cell | null;

property activeNotebookPanel

activeNotebookPanel: NotebookPanel | null;

property selectedCells

selectedCells: Cell[];

method addItem

addItem: (options: NotebookTools.IAddOptions) => void;

property activeCell

readonly activeCell: Cell | null;

• The currently focused cell.

  #### Notes If there is no cell with the focus, then this value is null.

property activeCellChanged

readonly activeCellChanged: ISignal<this, Cell | null>;

• A signal emitted when the current active cell changes.

  #### Notes If there is no cell with the focus, then null will be emitted.

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state changes.

function createExecutionIndicatorItem

createExecutionIndicatorItem: (
    panel: NotebookPanel,
    translator: ITranslator,
    loadSettings: Promise<ISettingRegistry.ISettings> | undefined
) => Widget;

function getSettingValue

getSettingValue: (settings: ISettingRegistry.ISettings) => {
    showOnToolBar: boolean;
    showProgress: boolean;
};

variable defaultContentFactory

const defaultContentFactory: IContentFactory;

function changeCellType

changeCellType: (notebook: Notebook, value: nbformat.CellType) => void;

• Change the selected cell type(s).

  Parameter notebook

  The target notebook widget.

  Parameter value

  The target cell type.

  #### Notes It should preserve the widget mode. This action can be undone. The existing selection will be cleared. Any cells converted to markdown will be unrendered.

function clearAllOutputs

clearAllOutputs: (notebook: Notebook) => void;

• Clear all the code outputs on the widget.

  Parameter notebook

  The target notebook widget.

  #### Notes The widget mode will be preserved.

function clearOutputs

clearOutputs: (notebook: Notebook) => void;

• Clear the code outputs of the selected cells.

  Parameter notebook

  The target notebook widget.

  #### Notes The widget mode will be preserved.

function collapseAll

collapseAll: (notebook: Notebook) => any;

• Collapse all cells in given notebook.

  Parameter notebook

  The target notebook widget.

function copy

copy: (notebook: Notebook) => void;

• Copy the selected cell(s) data to a clipboard.

  Parameter notebook

  The target notebook widget.

function cut

cut: (notebook: Notebook) => void;

• Cut the selected cell data to a clipboard.

  Parameter notebook

  The target notebook widget.

  #### Notes This action can be undone. A new code cell is added if all cells are cut.

function deleteCells

deleteCells: (notebook: Notebook) => void;

• Delete the selected cells.

  Parameter notebook

  The target notebook widget.

  #### Notes The cell after the last selected cell will be activated. It will add a code cell if all cells are deleted. This action can be undone.

function deselectAll

deselectAll: (notebook: Notebook) => void;

• Deselect all of the cells of the notebook.

  Parameter notebook

  the target notebook widget.

function disableOutputScrolling

disableOutputScrolling: (notebook: Notebook) => void;

• Disable output scrolling for all selected cells.

  Parameter notebook

  The target notebook widget.

function duplicate

duplicate: (
    notebook: Notebook,
    mode?: 'below' | 'belowSelected' | 'above' | 'replace'
) => void;

• Duplicate selected cells in the notebook without using the application clipboard.

  Parameter notebook

  The target notebook widget.

  Parameter mode

  the mode of adding cells: 'below' (default) adds cells below the active cell, 'belowSelected' adds cells below all selected cells, 'above' adds cells above the active cell, and 'replace' removes the currently selected cells and adds cells in their place.

  #### Notes The last pasted cell becomes the active cell. This is a no-op if there is no cell data on the clipboard. This action can be undone.

function enableOutputScrolling

enableOutputScrolling: (notebook: Notebook) => void;

• Enable output scrolling for all selected cells.

  Parameter notebook

  The target notebook widget.

function expandAllHeadings

expandAllHeadings: (notebook: Notebook) => any;

• Un-collapse all cells in given notebook.

  Parameter notebook

  The target notebook widget.

function expandParent

expandParent: (cell: Cell, notebook: Notebook) => void;

• Finds the "parent" heading of the given cell and expands. Used for the case that a cell becomes active that is within a collapsed heading.

  Parameter cell

  "Child" cell that has become the active cell

  Parameter notebook

  The target notebook widget.

function extendSelectionAbove

extendSelectionAbove: (notebook: Notebook, toTop?: boolean) => void;

• Extend the selection to the cell above.

  Parameter notebook

  The target notebook widget.

  Parameter toTop

  If true, denotes selection to extend to the top.

  #### Notes This is a no-op if the first cell is the active cell. The new cell will be activated.

function extendSelectionBelow

extendSelectionBelow: (notebook: Notebook, toBottom?: boolean) => void;

• Extend the selection to the cell below.

  Parameter notebook

  The target notebook widget.

  Parameter toBottom

  If true, denotes selection to extend to the bottom.

  #### Notes This is a no-op if the last cell is the active cell. The new cell will be activated.

function findNextParentHeading

findNextParentHeading: (cell: Cell, notebook: Notebook) => number;

• Finds the next heading that isn't a child of the given markdown heading.

  Parameter cell

  "Child" cell that has become the active cell

  Parameter notebook

  The target notebook widget.

function getHeadingInfo

getHeadingInfo: (cell: Cell) => {
    isHeading: boolean;
    headingLevel: number;
    collapsed?: boolean;
};

• If given cell is a markdown heading, returns the heading level. If given cell is not markdown, returns 7 (there are only 6 levels of markdown headings)

  Parameter cell

  The target cell widget.

function hideAllCode

hideAllCode: (notebook: Notebook) => void;

• Hide the code on all code cells.

  Parameter notebook

  The target notebook widget.

function hideAllOutputs

hideAllOutputs: (notebook: Notebook) => void;

• Hide the output on all code cells.

  Parameter notebook

  The target notebook widget.

function hideCode

hideCode: (notebook: Notebook) => void;

• Hide the code on selected code cells.

  Parameter notebook

  The target notebook widget.

function hideOutput

hideOutput: (notebook: Notebook) => void;

• Hide the output on selected code cells.

  Parameter notebook

  The target notebook widget.

function insertAbove

insertAbove: (notebook: Notebook) => void;

• Insert a new code cell above the active cell or in index 0 if the notebook is empty.

  Parameter notebook

  The target notebook widget.

  #### Notes The widget mode will be preserved. This action can be undone. The existing selection will be cleared. The new cell will the active cell.

function insertBelow

insertBelow: (notebook: Notebook) => void;

• Insert a new code cell below the active cell or in index 0 if the notebook is empty.

  Parameter notebook

  The target notebook widget.

  #### Notes The widget mode will be preserved. This action can be undone. The existing selection will be cleared. The new cell will be the active cell.

function mergeCells

mergeCells: (notebook: Notebook, mergeAbove?: boolean) => void;

• Merge the selected cells.

  Parameter notebook

  The target notebook widget.

  Parameter mergeAbove

  If only one cell is selected, indicates whether to merge it with the cell above (true) or below (false, default).

  #### Notes The widget mode will be preserved. If only one cell is selected and mergeAbove is true, the above cell will be selected. If only one cell is selected and mergeAbove is false, the below cell will be selected. If the active cell is a code cell, its outputs will be cleared. This action can be undone. The final cell will have the same type as the active cell. If the active cell is a markdown cell, it will be unrendered.

function moveDown

moveDown: (notebook: Notebook) => void;

• Move the selected cell(s) down.

  Parameter notebook

  = The target notebook widget.

function moveUp

moveUp: (notebook: Notebook) => void;

• Move the selected cell(s) up.

  Parameter widget

  The target notebook widget.

function paste

paste: (
    notebook: Notebook,
    mode?: 'below' | 'belowSelected' | 'above' | 'replace'
) => void;

• Paste cells from the application clipboard.

  Parameter notebook

  The target notebook widget.

  Parameter mode

  the mode of adding cells: 'below' (default) adds cells below the active cell, 'belowSelected' adds cells below all selected cells, 'above' adds cells above the active cell, and 'replace' removes the currently selected cells and adds cells in their place.

  #### Notes The last pasted cell becomes the active cell. This is a no-op if there is no cell data on the clipboard. This action can be undone.

function redo

redo: (notebook: Notebook) => void;

• Redo a cell action.

  Parameter notebook

  The target notebook widget.

  #### Notes This is a no-op if there are no cell actions to redo.

function renderAllMarkdown

renderAllMarkdown: (
    notebook: Notebook,
    sessionContext?: ISessionContext
) => Promise<boolean>;

function renderDefault

renderDefault: (notebook: Notebook) => void;

• Render not side-by-side.

  Parameter notebook

  The target notebook widget.

function renderSideBySide

renderSideBySide: (notebook: Notebook) => void;

• Render side-by-side.

  Parameter notebook

  The target notebook widget.

function replaceSelection

replaceSelection: (notebook: Notebook, text: string) => void;

• Replaces the selection in the active cell of the notebook.

  Parameter notebook

  The target notebook widget.

  Parameter text

  The text to replace the selection.

function run

run: (notebook: Notebook, sessionContext?: ISessionContext) => Promise<boolean>;

• Run the selected cell(s).

  Parameter notebook

  The target notebook widget.

  Parameter sessionContext

  The optional client session object.

  #### Notes The last selected cell will be activated, but not scrolled into view. The existing selection will be cleared. An execution error will prevent the remaining code cells from executing. All markdown cells will be rendered.

function runAll

runAll: (
    notebook: Notebook,
    sessionContext?: ISessionContext
) => Promise<boolean>;