@jupyterlab/cell-toolbar 4.0.0-alpha.6 → 4.0.0-beta.0

package/src/celltoolbartracker.ts

@@ -0,0 +1,479 @@
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+import { createDefaultFactory, ToolbarRegistry } from '@jupyterlab/apputils';
+import {
+  Cell,
+  CellModel,
+  CodeCell,
+  ICellModel,
+  MarkdownCell
+} from '@jupyterlab/cells';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Notebook, NotebookPanel } from '@jupyterlab/notebook';
+import { IObservableList, ObservableList } from '@jupyterlab/observables';
+import { ReactWidget, Toolbar } from '@jupyterlab/ui-components';
+import { some } from '@lumino/algorithm';
+import { CommandRegistry } from '@lumino/commands';
+import { IDisposable } from '@lumino/disposable';
+import { Signal } from '@lumino/signaling';
+import { PanelLayout, Widget } from '@lumino/widgets';
+import { IMapChange } from '@jupyter/ydoc';
+
+/*
+ * Text mime types
+ */
+const TEXT_MIME_TYPES = [
+  'text/plain',
+  'application/vnd.jupyter.stdout',
+  'application/vnd.jupyter.stderr'
+];
+
+/**
+ * Widget cell toolbar classes
+ */
+const CELL_TOOLBAR_CLASS = 'jp-cell-toolbar';
+const CELL_MENU_CLASS = 'jp-cell-menu';
+
+/**
+ * Class for a cell whose contents overlap with the cell toolbar
+ */
+const TOOLBAR_OVERLAP_CLASS = 'jp-toolbar-overlap';
+
+/**
+ * Watch a notebook so that a cell toolbar appears on the active cell
+ */
+export class CellToolbarTracker implements IDisposable {
+  constructor(
+    panel: NotebookPanel,
+    toolbar: IObservableList<ToolbarRegistry.IToolbarItem>
+  ) {
+    this._panel = panel;
+    this._previousActiveCell = this._panel.content.activeCell;
+    this._toolbar = toolbar;
+
+    this._onToolbarChanged();
+    this._toolbar.changed.connect(this._onToolbarChanged, this);
+
+    // Only add the toolbar to the notebook's active cell (if any) once it has fully rendered and been revealed.
+    void panel.revealed.then(() => {
+      // Wait one frame (at 60 fps) for the panel to render the first cell, then display the cell toolbar on it if possible.
+      setTimeout(() => {
+        this._onActiveCellChanged(panel.content);
+      }, 1000 / 60);
+    });
+
+    // Check whether the toolbar should be rendered upon a layout change
+    panel.content.renderingLayoutChanged.connect(
+      this._onActiveCellChanged,
+      this
+    );
+
+    // Handle subsequent changes of active cell.
+    panel.content.activeCellChanged.connect(this._onActiveCellChanged, this);
+    panel.content.activeCell?.model.metadataChanged.connect(
+      this._onMetadataChanged,
+      this
+    );
+    panel.disposed.connect(() => {
+      panel.content.activeCellChanged.disconnect(this._onActiveCellChanged);
+      panel.content.activeCell?.model.metadataChanged.disconnect(
+        this._onMetadataChanged
+      );
+    });
+  }
+
+  _onMetadataChanged(model: CellModel, args: IMapChange) {
+    if (args.key === 'jupyter') {
+      if (
+        typeof args.newValue === 'object' &&
+        args.newValue.source_hidden === true &&
+        (args.type === 'add' || args.type === 'change')
+      ) {
+        // Cell just became hidden; remove toolbar
+        this._removeToolbar(model);
+      }
+      // Check whether input visibility changed
+      else if (
+        typeof args.oldValue === 'object' &&
+        args.oldValue.source_hidden === true
+      ) {
+        // Cell just became visible; add toolbar
+        this._addToolbar(model);
+      }
+    }
+  }
+  _onActiveCellChanged(notebook: Notebook): void {
+    if (this._previousActiveCell && !this._previousActiveCell.isDisposed) {
+      // Disposed cells do not have a model anymore.
+      this._removeToolbar(this._previousActiveCell.model);
+      this._previousActiveCell.model.metadataChanged.disconnect(
+        this._onMetadataChanged
+      );
+    }
+
+    const activeCell = notebook.activeCell;
+    if (activeCell === null || activeCell.inputHidden) {
+      return;
+    }
+
+    activeCell.model.metadataChanged.connect(this._onMetadataChanged, this);
+
+    this._addToolbar(activeCell.model);
+    this._previousActiveCell = activeCell;
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  dispose(): void {
+    if (this.isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+
+    this._toolbar.changed.disconnect(this._onToolbarChanged, this);
+
+    const cells = this._panel?.context.model.cells;
+    if (cells) {
+      for (const model of cells) {
+        this._removeToolbar(model);
+      }
+    }
+
+    this._panel = null;
+
+    Signal.clearData(this);
+  }
+
+  private _addToolbar(model: ICellModel): void {
+    const cell = this._getCell(model);
+
+    if (cell) {
+      const toolbarWidget = new Toolbar();
+      toolbarWidget.addClass(CELL_MENU_CLASS);
+
+      const promises: Promise<void>[] = [];
+      for (const { name, widget } of this._toolbar) {
+        toolbarWidget.addItem(name, widget);
+        if (
+          widget instanceof ReactWidget &&
+          (widget as ReactWidget).renderPromise !== undefined
+        ) {
+          (widget as ReactWidget).update();
+          promises.push((widget as ReactWidget).renderPromise!);
+        }
+      }
+
+      // Wait for all the buttons to be rendered before attaching the toolbar.
+      Promise.all(promises)
+        .then(() => {
+          toolbarWidget.addClass(CELL_TOOLBAR_CLASS);
+          (cell.layout as PanelLayout).insertWidget(0, toolbarWidget);
+
+          // For rendered markdown, watch for resize events.
+          cell.displayChanged.connect(this._resizeEventCallback, this);
+
+          // Watch for changes in the cell's contents.
+          cell.model.contentChanged.connect(this._changedEventCallback, this);
+
+          // Hide the cell toolbar if it overlaps with cell contents
+          this._updateCellForToolbarOverlap(cell);
+        })
+        .catch(e => {
+          console.error('Error rendering buttons of the cell toolbar: ', e);
+        });
+    }
+  }
+
+  private _getCell(model: ICellModel): Cell | undefined {
+    return this._panel?.content.widgets.find(widget => widget.model === model);
+  }
+
+  private _findToolbarWidgets(cell: Cell): Widget[] {
+    const widgets = (cell.layout as PanelLayout).widgets;
+
+    // Search for header using the CSS class or use the first one if not found.
+    return widgets.filter(widget => widget.hasClass(CELL_TOOLBAR_CLASS)) || [];
+  }
+
+  private _removeToolbar(model: ICellModel): void {
+    const cell = this._getCell(model);
+    if (cell) {
+      this._findToolbarWidgets(cell).forEach(widget => {
+        widget.dispose();
+      });
+      // Attempt to remove the resize and changed event handlers.
+      cell.displayChanged.disconnect(this._resizeEventCallback, this);
+    }
+    model.contentChanged.disconnect(this._changedEventCallback, this);
+  }
+
+  /**
+   * Call back on settings changes
+   */
+  private _onToolbarChanged(): void {
+    // Reset toolbar when settings changes
+    const activeCell: Cell<ICellModel> | null | undefined =
+      this._panel?.content.activeCell;
+    if (activeCell) {
+      this._removeToolbar(activeCell.model);
+      this._addToolbar(activeCell.model);
+    }
+  }
+
+  private _changedEventCallback(): void {
+    const activeCell = this._panel?.content.activeCell;
+    if (activeCell === null || activeCell === undefined) {
+      return;
+    }
+
+    this._updateCellForToolbarOverlap(activeCell);
+  }
+
+  private _resizeEventCallback(): void {
+    const activeCell = this._panel?.content.activeCell;
+    if (activeCell === null || activeCell === undefined) {
+      return;
+    }
+
+    this._updateCellForToolbarOverlap(activeCell);
+  }
+
+  private _updateCellForToolbarOverlap(activeCell: Cell<ICellModel>) {
+    // Remove the "toolbar overlap" class from the cell, rendering the cell's toolbar
+    const activeCellElement = activeCell.node;
+    activeCellElement.classList.remove(TOOLBAR_OVERLAP_CLASS);
+
+    if (this._cellToolbarOverlapsContents(activeCell)) {
+      // Add the "toolbar overlap" class to the cell, completely concealing the toolbar,
+      // if the first line of the content overlaps with it at all
+      activeCellElement.classList.add(TOOLBAR_OVERLAP_CLASS);
+    }
+  }
+
+  private _cellToolbarOverlapsContents(activeCell: Cell<ICellModel>): boolean {
+    const cellType = activeCell.model.type;
+
+    // If the toolbar is too large for the current cell, hide it.
+    const cellLeft = this._cellEditorWidgetLeft(activeCell);
+    const cellRight = this._cellEditorWidgetRight(activeCell);
+    const toolbarLeft = this._cellToolbarLeft(activeCell);
+
+    if (toolbarLeft === null) {
+      return false;
+    }
+
+    // The toolbar should not take up more than 50% of the cell.
+    if ((cellLeft + cellRight) / 2 > toolbarLeft) {
+      return true;
+    }
+
+    if (cellType === 'markdown' && (activeCell as MarkdownCell).rendered) {
+      // Check for overlap in rendered markdown content
+      return this._markdownOverlapsToolbar(activeCell as MarkdownCell);
+    }
+
+    // Check for overlap in code content
+    if (this._panel?.content.renderingLayout === 'default') {
+      return this._codeOverlapsToolbar(activeCell);
+    } else {
+      return this._outputOverlapsToolbar(activeCell);
+    }
+  }
+
+  /**
+   * Check for overlap between rendered Markdown and the cell toolbar
+   *
+   * @param activeCell A rendered MarkdownCell
+   * @returns `true` if the first line of the output overlaps with the cell toolbar, `false` otherwise
+   */
+  private _markdownOverlapsToolbar(activeCell: MarkdownCell): boolean {
+    const markdownOutput = activeCell.inputArea; // Rendered markdown appears in the input area
+    if (!markdownOutput) {
+      return false;
+    }
+
+    // Get the rendered markdown as a widget.
+    const markdownOutputWidget = markdownOutput.renderedInput;
+    const markdownOutputElement = markdownOutputWidget.node;
+
+    const firstOutputElementChild =
+      markdownOutputElement.firstElementChild as HTMLElement;
+    if (firstOutputElementChild === null) {
+      return false;
+    }
+
+    // Temporarily set the element's max width so that the bounding client rectangle only encompasses the content.
+    const oldMaxWidth = firstOutputElementChild.style.maxWidth;
+    firstOutputElementChild.style.maxWidth = 'max-content';
+
+    const lineRight = firstOutputElementChild.getBoundingClientRect().right;
+
+    // Reinstate the old max width.
+    firstOutputElementChild.style.maxWidth = oldMaxWidth;
+
+    const toolbarLeft = this._cellToolbarLeft(activeCell);
+
+    return toolbarLeft === null ? false : lineRight > toolbarLeft;
+  }
+
+  private _outputOverlapsToolbar(activeCell: Cell<ICellModel>): boolean {
+    const outputArea = (activeCell as CodeCell).outputArea.node;
+    if (outputArea) {
+      const outputs = outputArea.querySelectorAll('[data-mime-type]');
+      const toolbarRect = this._cellToolbarRect(activeCell);
+      if (toolbarRect) {
+        const { left: toolbarLeft, bottom: toolbarBottom } = toolbarRect;
+        return some(outputs, output => {
+          const node = output.firstElementChild;
+          if (node) {
+            const range = new Range();
+            if (
+              TEXT_MIME_TYPES.includes(
+                output.getAttribute('data-mime-type') || ''
+              )
+            ) {
+              // If the node is plain text, it's in a <pre>. To get the true bounding box of the
+              // text, the node contents need to be selected.
+              range.selectNodeContents(node);
+            } else {
+              range.selectNode(node);
+            }
+            const { right: nodeRight, top: nodeTop } =
+              range.getBoundingClientRect();
+
+            // Note: y-coordinate increases toward the bottom of page
+            return nodeRight > toolbarLeft && nodeTop < toolbarBottom;
+          }
+          return false;
+        });
+      }
+    }
+    return false;
+  }
+
+  private _codeOverlapsToolbar(activeCell: Cell<ICellModel>): boolean {
+    const editorWidget = activeCell.editorWidget;
+    const editor = activeCell.editor;
+    if (!editorWidget || !editor) {
+      return false;
+    }
+
+    if (editor.lineCount < 1) {
+      return false; // Nothing in the editor
+    }
+
+    const codeMirrorLines = editorWidget.node.getElementsByClassName('cm-line');
+    if (codeMirrorLines.length < 1) {
+      return false; // No lines present
+    }
+
+    let lineRight = codeMirrorLines[0].getBoundingClientRect().left;
+    const range = document.createRange();
+    range.selectNodeContents(codeMirrorLines[0]);
+    lineRight += range.getBoundingClientRect().width;
+
+    const toolbarLeft = this._cellToolbarLeft(activeCell);
+
+    return toolbarLeft === null ? false : lineRight > toolbarLeft;
+  }
+
+  private _cellEditorWidgetLeft(activeCell: Cell<ICellModel>): number {
+    return activeCell.editorWidget?.node.getBoundingClientRect().left ?? 0;
+  }
+
+  private _cellEditorWidgetRight(activeCell: Cell<ICellModel>): number {
+    return activeCell.editorWidget?.node.getBoundingClientRect().right ?? 0;
+  }
+
+  private _cellToolbarRect(activeCell: Cell<ICellModel>): DOMRect | null {
+    const toolbarWidgets = this._findToolbarWidgets(activeCell);
+    if (toolbarWidgets.length < 1) {
+      return null;
+    }
+    const activeCellToolbar = toolbarWidgets[0].node;
+
+    return activeCellToolbar.getBoundingClientRect();
+  }
+
+  private _cellToolbarLeft(activeCell: Cell<ICellModel>): number | null {
+    return this._cellToolbarRect(activeCell)?.left || null;
+  }
+
+  private _isDisposed = false;
+  private _panel: NotebookPanel | null;
+  private _previousActiveCell: Cell<ICellModel> | null;
+  private _toolbar: IObservableList<ToolbarRegistry.IToolbarItem>;
+}
+
+const defaultToolbarItems: ToolbarRegistry.IWidget[] = [
+  {
+    command: 'notebook:duplicate-below',
+    name: 'duplicate-cell'
+  },
+  {
+    command: 'notebook:move-cell-up',
+    name: 'move-cell-up'
+  },
+  {
+    command: 'notebook:move-cell-down',
+    name: 'move-cell-down'
+  },
+  {
+    command: 'notebook:insert-cell-above',
+    name: 'insert-cell-above'
+  },
+  {
+    command: 'notebook:insert-cell-below',
+    name: 'insert-cell-below'
+  },
+  {
+    command: 'notebook:delete-cell',
+    name: 'delete-cell'
+  }
+];
+
+/**
+ * Widget extension that creates a CellToolbarTracker each time a notebook is
+ * created.
+ */
+export class CellBarExtension implements DocumentRegistry.WidgetExtension {
+  static FACTORY_NAME = 'Cell';
+
+  constructor(
+    commands: CommandRegistry,
+    toolbarFactory?: (
+      widget: Widget
+    ) => IObservableList<ToolbarRegistry.IToolbarItem>
+  ) {
+    this._commands = commands;
+    this._toolbarFactory = toolbarFactory ?? this.defaultToolbarFactory;
+  }
+
+  protected get defaultToolbarFactory(): (
+    widget: Widget
+  ) => IObservableList<ToolbarRegistry.IToolbarItem> {
+    const itemFactory = createDefaultFactory(this._commands);
+    return (widget: Widget) =>
+      new ObservableList({
+        values: defaultToolbarItems.map(item => {
+          return {
+            name: item.name,
+            widget: itemFactory(CellBarExtension.FACTORY_NAME, widget, item)
+          };
+        })
+      });
+  }
+
+  createNew(panel: NotebookPanel): IDisposable {
+    return new CellToolbarTracker(panel, this._toolbarFactory(panel));
+  }
+
+  private _commands: CommandRegistry;
+  private _toolbarFactory: (
+    widget: Widget
+  ) => IObservableList<ToolbarRegistry.IToolbarItem>;
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+/**
+ * @packageDocumentation
+ * @module cell-toolbar
+ */
+export * from './celltoolbartracker';

package/style/base.css

@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
 .jp-cell-button .jp-icon3[fill] {
   fill: var(--jp-inverse-layout-color4);
 }
@@ -15,20 +20,21 @@
   flex-direction: row;
   padding: 2px 0;
   min-height: 25px;
-  z-index: 10;
+  z-index: 6;
   position: absolute;
   top: 5px;
   right: 8px;
+
+  /* Override .jp-Toolbar */
+  background-color: inherit;
+  border-bottom: inherit;
+  box-shadow: inherit;
 }
 
-/* Overrides for mobile view: Move cell toolbar up, don't hide it if it overlaps */
+/* Overrides for mobile view hiding cell toolbar */
 @media only screen and (max-width: 760px) {
-  .jp-toolbar-overlap .jp-cell-toolbar {
-    display: block;
-  }
-
-  .jp-cell-toolbar {
-    top: -5px;
+  .jp-cell-menu.jp-cell-toolbar {
+    display: none;
   }
 }
 

package/lib/cellmenu.d.ts

@@ -1,20 +0,0 @@
-import { CommandRegistry } from '@lumino/commands';
-import { Widget } from '@lumino/widgets';
-import { ICellMenuItem } from './tokens';
-/**
- * Toolbar icon menu container
- */
-export declare class CellMenu extends Widget {
-    constructor(commands: CommandRegistry, items: ICellMenuItem[]);
-    handleEvent(event: Event): void;
-    /**
-     * Handle `after-attach` messages for the widget.
-     */
-    onAfterAttach(): void;
-    /**
-     * Handle `before-detach` messages for the widget.
-     */
-    onBeforeDetach(): void;
-    protected _addButtons(items: ICellMenuItem[]): void;
-    private _commands;
-}

package/lib/cellmenu.js

@@ -1,68 +0,0 @@
-/* -----------------------------------------------------------------------------
-| Copyright (c) Jupyter Development Team.
-| Distributed under the terms of the Modified BSD License.
-|----------------------------------------------------------------------------*/
-import { ToolbarButton } from '@jupyterlab/apputils';
-import { LabIcon } from '@jupyterlab/ui-components';
-import { each } from '@lumino/algorithm';
-import { PanelLayout, Widget } from '@lumino/widgets';
-const CELL_MENU_CLASS = 'jp-cell-menu';
-/**
- * Toolbar icon menu container
- */
-export class CellMenu extends Widget {
-    constructor(commands, items) {
-        super();
-        this._commands = commands;
-        this.layout = new PanelLayout();
-        this.addClass(CELL_MENU_CLASS);
-        this._addButtons(items);
-    }
-    handleEvent(event) {
-        switch (event.type) {
-            case 'mousedown':
-            case 'click':
-                // Ensure the mouse event is not propagated on the cell.
-                event.stopPropagation();
-                break;
-        }
-    }
-    /**
-     * Handle `after-attach` messages for the widget.
-     */
-    onAfterAttach() {
-        this.node.addEventListener('mousedown', this);
-        this.node.addEventListener('click', this);
-    }
-    /**
-     * Handle `before-detach` messages for the widget.
-     */
-    onBeforeDetach() {
-        this.node.removeEventListener('mousedown', this);
-        this.node.removeEventListener('click', this);
-    }
-    _addButtons(items) {
-        each(this.children(), widget => {
-            widget.dispose();
-        });
-        const layout = this.layout;
-        items.forEach(entry => {
-            var _a, _b;
-            if (this._commands.hasCommand(entry.command)) {
-                layout.addWidget(new ToolbarButton({
-                    icon: LabIcon.resolve({ icon: entry.icon }),
-                    className: `jp-cell-${(_a = entry.cellType) !== null && _a !== void 0 ? _a : 'all'}`,
-                    onClickWithEvent: (e) => {
-                        // Prevent propagation of this event in case the command causes the
-                        // current cell to move. If the cell moves and the event propagates to the
-                        // new cell, this may have an effect on the new cell.
-                        void this._commands.execute(entry.command);
-                        e.stopPropagation();
-                    },
-                    tooltip: (_b = entry.tooltip) !== null && _b !== void 0 ? _b : this._commands.label(entry.command)
-                }));
-            }
-        });
-    }
-}
-//# sourceMappingURL=cellmenu.js.map

package/lib/cellmenu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cellmenu.js","sourceRoot":"","sources":["../src/cellmenu.ts"],"names":[],"mappings":"AAAA;;;+EAG+E;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGtD,MAAM,eAAe,GAAG,cAAc,CAAC;AAEvC;;GAEG;AACH,MAAM,OAAO,QAAS,SAAQ,MAAM;IAClC,YAAY,QAAyB,EAAE,KAAsB;QAC3D,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAC/B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,WAAW,CAAC,KAAY;QACtB,QAAQ,KAAK,CAAC,IAAI,EAAE;YAClB,KAAK,WAAW,CAAC;YACjB,KAAK,OAAO;gBACV,wDAAwD;gBACxD,KAAK,CAAC,eAAe,EAAE,CAAC;gBACxB,MAAM;SACT;IACH,CAAC;IAED;;OAEG;IACH,aAAa;QACX,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;IAES,WAAW,CAAC,KAAsB;QAC1C,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,EAAE;YAC7B,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,IAAI,CAAC,MAAqB,CAAC;QAC1C,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;;YACpB,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;gBAC5C,MAAM,CAAC,SAAS,CACd,IAAI,aAAa,CAAC;oBAChB,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;oBAC3C,SAAS,EAAE,WAAW,MAAA,KAAK,CAAC,QAAQ,mCAAI,KAAK,EAAE;oBAC/C,gBAAgB,EAAE,CAAC,CAAQ,EAAQ,EAAE;wBACnC,mEAAmE;wBACnE,0EAA0E;wBAC1E,qDAAqD;wBACrD,KAAK,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;wBAC3C,CAAC,CAAC,eAAe,EAAE,CAAC;oBACtB,CAAC;oBACD,OAAO,EAAE,MAAA,KAAK,CAAC,OAAO,mCAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;iBAC9D,CAAC,CACH,CAAC;aACH;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CAGF"}

package/lib/celltoolbarwidget.d.ts

@@ -1,9 +0,0 @@
-import { CommandRegistry } from '@lumino/commands';
-import { Widget } from '@lumino/widgets';
-import { ICellMenuItem } from './tokens';
-/**
- * Cell Toolbar Widget
- */
-export declare class CellToolbarWidget extends Widget {
-    constructor(commands: CommandRegistry, menuItems: ICellMenuItem[]);
-}

package/lib/celltoolbarwidget.js

@@ -1,14 +0,0 @@
-import { PanelLayout, Widget } from '@lumino/widgets';
-import { CellMenu } from './cellmenu';
-/**
- * Cell Toolbar Widget
- */
-export class CellToolbarWidget extends Widget {
-    constructor(commands, menuItems) {
-        super();
-        this.layout = new PanelLayout();
-        this.addClass('jp-cell-toolbar');
-        this.layout.addWidget(new CellMenu(commands, menuItems));
-    }
-}
-//# sourceMappingURL=celltoolbarwidget.js.map

package/lib/celltoolbarwidget.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"celltoolbarwidget.js","sourceRoot":"","sources":["../src/celltoolbarwidget.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,MAAM;IAC3C,YAAY,QAAyB,EAAE,SAA0B;QAC/D,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QAEhC,IAAI,CAAC,MAAsB,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;IAC5E,CAAC;CACF"}

package/lib/tokens.d.ts

@@ -1,25 +0,0 @@
-import { LabIcon } from '@jupyterlab/ui-components';
-export declare const EXTENSION_ID = "@jupyterlab/cell-toolbar";
-/**
- * Menu action interface
- */
-export interface ICellMenuItem {
-    /**
-     * Command to be triggered
-     */
-    command: string;
-    /**
-     * Icon for the item
-     */
-    icon: LabIcon | string;
-    /**
-     * Icon tooltip
-     */
-    tooltip?: string;
-    /**
-     * Type of cell it applies on
-     *
-     * Undefined if it applies on all cell types
-     */
-    cellType?: 'code' | 'markdown' | 'raw';
-}

package/lib/tokens.js

@@ -1,2 +0,0 @@
-export const EXTENSION_ID = '@jupyterlab/cell-toolbar';
-//# sourceMappingURL=tokens.js.map

package/lib/tokens.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,YAAY,GAAG,0BAA0B,CAAC"}