@opensumi/ide-notebook 3.5.1-next-1732847732.0 → 3.5.1-next-1733450080.0

package/src/browser/libro-keybind-contribution.ts

@@ -1,26 +1,24 @@
-import { LibroSearchToggleCommand, LibroService, NotebookCommands } from '@difizen/libro-jupyter/noeditor';
+import { LibroSearchToggleCommand, LibroService, LibroView, NotebookCommands } from '@difizen/libro-jupyter/noeditor';
 import { Container, CommandRegistry as LibroCommandRegistry } from '@difizen/mana-app';
 
 import { Autowired } from '@opensumi/di';
 import {
   ClientAppContribution,
-  CommandContribution,
   CommandRegistry,
   Domain,
   IContextKeyService,
-  KeybindingContribution,
   KeybindingRegistry,
   KeybindingScope,
-  MaybePromise,
 } from '@opensumi/ide-core-browser';
 import { WorkbenchEditorService } from '@opensumi/ide-editor';
 
 import { LIBRO_COMPONENTS_SCHEME_ID } from './libro.protocol';
 import { ManaContainer } from './mana';
 
-@Domain(ClientAppContribution, KeybindingContribution, CommandContribution)
-export class LibroKeybindContribution implements ClientAppContribution, KeybindingContribution, CommandContribution {
+@Domain(ClientAppContribution)
+export class LibroKeybindContribution implements ClientAppContribution {
   @Autowired(IContextKeyService) contextKeyService: IContextKeyService;
+  @Autowired(KeybindingRegistry) keybindingRegistry: KeybindingRegistry;
   @Autowired(WorkbenchEditorService)
   workbenchEditorService: WorkbenchEditorService;
   @Autowired(CommandRegistry)
@@ -28,12 +26,17 @@ export class LibroKeybindContribution implements ClientAppContribution, Keybindi
   @Autowired(ManaContainer)
   private readonly manaContainer: Container;
 
-  initialize(): MaybePromise<void> {
+  onStart() {
     this.registerContextKey();
+    this.registerCommand();
+    this.registerKeybind();
   }
 
   registerContextKey() {
-    const notebookFocusContext = this.contextKeyService.createKey<boolean>('libroNotebookFocused', false);
+    const notebookFocusContext = this.contextKeyService.createKey<boolean>(
+      'libroNotebookFocused',
+      this.hasActiveNotebook(),
+    );
 
     this.workbenchEditorService.onActiveResourceChange((e) => {
       if (e?.uri?.path.ext === `.${LIBRO_COMPONENTS_SCHEME_ID}`) {
@@ -52,41 +55,45 @@ export class LibroKeybindContribution implements ClientAppContribution, Keybindi
     return this.manaContainer.get(LibroCommandRegistry);
   }
 
-  registerCommands(commands: CommandRegistry) {
-    commands.registerCommand(NotebookCommands['EnterCommandMode'], {
+  hasActiveNotebook() {
+    return this.libroService.active instanceof LibroView;
+  }
+
+  registerCommand() {
+    this.commandRegistry.registerCommand(NotebookCommands['EnterCommandMode'], {
       execute: () => {
         this.libroCommandRegistry.executeCommand(NotebookCommands['EnterCommandMode'].id);
       },
     });
-    commands.registerCommand(NotebookCommands['RunCell'], {
+    this.commandRegistry.registerCommand(NotebookCommands['RunCell'], {
       execute: () => {
         this.libroCommandRegistry.executeCommand(NotebookCommands['RunCell'].id);
       },
     });
-    commands.registerCommand(NotebookCommands['RunCellAndSelectNext'], {
+    this.commandRegistry.registerCommand(NotebookCommands['RunCellAndSelectNext'], {
       execute: () => {
         this.libroCommandRegistry.executeCommand(NotebookCommands['RunCellAndSelectNext'].id);
       },
     });
-    commands.registerCommand(NotebookCommands['RunCellAndInsertBelow'], {
+    this.commandRegistry.registerCommand(NotebookCommands['RunCellAndInsertBelow'], {
       execute: () => {
         this.libroCommandRegistry.executeCommand(NotebookCommands['RunCellAndInsertBelow'].id);
       },
     });
-    commands.registerCommand(NotebookCommands['SplitCellAntCursor'], {
+    this.commandRegistry.registerCommand(NotebookCommands['SplitCellAntCursor'], {
       execute: () => {
         this.libroCommandRegistry.executeCommand(NotebookCommands['SplitCellAntCursor'].id);
       },
     });
-    commands.registerCommand(LibroSearchToggleCommand.ShowLibroSearch, {
+    this.commandRegistry.registerCommand(LibroSearchToggleCommand.ShowLibroSearch, {
       execute: () => {
         this.libroCommandRegistry.executeCommand(LibroSearchToggleCommand.ShowLibroSearch.id);
       },
     });
   }
 
-  registerKeybindings(keybindings: KeybindingRegistry): void {
-    keybindings.registerKeybindings(
+  registerKeybind() {
+    this.keybindingRegistry.registerKeybindings(
       [
         {
           keybinding: 'f1',

package/src/browser/libro.contribution.tsx

@@ -15,8 +15,6 @@ import {
   ClientAppContribution,
   CommandContribution,
   type CommandRegistry,
-  ComponentContribution,
-  ComponentRegistry,
   Disposable,
   Domain,
   IClientApp,
@@ -24,7 +22,6 @@ import {
   OpenerContribution,
   Schemes,
   URI,
-  localize,
 } from '@opensumi/ide-core-browser';
 import { message } from '@opensumi/ide-core-browser/lib/components';
 import {
@@ -39,7 +36,7 @@ import { IEditorDocumentModelContentRegistry } from '@opensumi/ide-editor/lib/br
 import { IconService } from '@opensumi/ide-theme/lib/browser';
 import { IThemeService, IconType } from '@opensumi/ide-theme/lib/common';
 
-import { KERNEL_PANEL_ID, KernelPanel, initKernelPanelColorToken } from './kernel-panel';
+import { initKernelPanelColorToken } from './kernel-panel';
 import { LibroOpensumiModule } from './libro';
 import { LibroOpener } from './libro-opener';
 import { initLibroColorToken } from './libro.color.tokens';
@@ -49,9 +46,6 @@ import { ManaContainer, initLibroOpensumi, manaContainer } from './mana/index';
 import { NotebookDocumentContentProvider } from './notebook-document-content-provider';
 import { NotebookServiceOverride } from './notebook.service';
 import { initTocPanelColorToken } from './toc';
-import { LibroVariableModule } from './variables/libro-variable-module';
-import { VariablePanel } from './variables/variable-panel';
-import { VARIABLE_ID } from './variables/variable-protocol';
 
 const LIBRO_COMPONENTS_VIEW_COMMAND = {
   id: 'opensumi-libro',
@@ -62,7 +56,7 @@ const LayoutWrapper: React.FC<React.PropsWithChildren> = ({ children }) => {
   return (
     <ManaComponents.Application
       context={{ container: manaContainer }}
-      modules={[ManaAppPreset, LibroJupyterNoEditorModule, LibroTOCModule, LibroOpensumiModule, LibroVariableModule]}
+      modules={[ManaAppPreset, LibroJupyterNoEditorModule, LibroTOCModule, LibroOpensumiModule]}
       renderChildren
       onReady={() => setIsReady(true)}
     >
@@ -71,15 +65,12 @@ const LayoutWrapper: React.FC<React.PropsWithChildren> = ({ children }) => {
   );
 };
 
-export const NOTE_BOOK_PANEL_ID = 'notebook-panel';
-
 @Domain(
   ClientAppContribution,
   BrowserEditorContribution,
   ClientAppContextContribution,
   CommandContribution,
   OpenerContribution,
-  ComponentContribution,
 )
 export class LibroContribution
   extends Disposable
@@ -88,8 +79,7 @@ export class LibroContribution
     BrowserEditorContribution,
     ClientAppContextContribution,
     CommandContribution,
-    OpenerContribution,
-    ComponentContribution
+    OpenerContribution
 {
   @Autowired(ManaContainer)
   private readonly manaContainer: Container;
@@ -125,40 +115,6 @@ export class LibroContribution
     initLibroOpensumi(app.injector, manaContainer);
   }
 
-  registerComponent(registry: ComponentRegistry) {
-    const iconClass = this.iconService.fromIcon(
-      '',
-      {
-        dark: 'https://mdn.alipayobjects.com/huamei_rm3rgy/afts/img/A*tFyaRbqux_4AAAAAAAAAAAAADr2GAQ/original',
-        light: 'https://mdn.alipayobjects.com/huamei_rm3rgy/afts/img/A*ebL7T4dWefUAAAAAAAAAAAAADr2GAQ/original',
-      },
-      IconType.Background,
-    );
-    registry.register(
-      '@opensumi/ide-notebook',
-      [
-        {
-          id: KERNEL_PANEL_ID,
-          name: localize('notebook.kernel.panel.title'),
-          component: KernelPanel,
-          priority: 0,
-        },
-        {
-          id: VARIABLE_ID,
-          name: localize('notebook.variable.panel.title'),
-          weight: 2,
-          priority: 1,
-          component: VariablePanel,
-        },
-      ],
-      {
-        activateKeyBinding: 'ctrlcmd+shift+k',
-        containerId: NOTE_BOOK_PANEL_ID,
-        iconClass,
-      },
-    );
-  }
-
   registerClientAppContext(Layout: React.FC, injector: Injector): React.FC {
     initLibroColorToken();
     initKernelPanelColorToken();

package/lib/browser/variables/index.less

@@ -1,102 +0,0 @@
-.libro-variable-content {
-  height: calc(100% - 40px);
-
-  .libro-variable-list {
-    height: 100%;
-    overflow-y: auto;
-
-    .ant-list-item {
-      padding: 4px 12px 0;
-      border-bottom: none;
-
-      &:hover {
-        border-radius: 6px;
-        background-color: var(--mana-libro-variable-background-hover-color);
-      }
-
-      .ant-list-item-meta {
-        border-bottom: 1px solid var(--mana-libro-variable-border-color);
-      }
-
-      .ant-list-item-meta-title {
-        color: var(--mana-libro-variable-title-color);
-
-        .libro-variable-title {
-          display: flex;
-          align-items: center;
-          justify-content: space-between;
-
-          .libro-variable-type-tag {
-            font-size: 10px;
-            margin-left: 8px;
-            color: var(--mana-libro-variable-tag-text-color);
-            background-color: var(--mana-libro-variable-tag-background-color);
-            border-radius: 4px;
-          }
-
-          .libro-variable-extra {
-            color: var(--mana-libro-variable-icon-color);
-            transform: rotate(90deg);
-
-            :hover {
-              color: #1890ff;
-              cursor: pointer;
-            }
-          }
-        }
-
-        .libro-variable-name {
-          color: var(--mana-libro-variable-name-color);
-        }
-      }
-
-      .ant-list-item-meta-description {
-        overflow: hidden;
-        color: var(--mana-libro-variable-description-color);
-        text-overflow: ellipsis;
-        white-space: nowrap;
-      }
-    }
-  }
-
-  .libro-variable-search {
-    display: flex;
-    align-items: center;
-    padding: 4px 12px 8px;
-
-    &-input {
-      background: var(--mana-libro-variable-search-background-color);
-      border: none;
-      border-radius: 6px;
-      height: 28px;
-
-      input {
-        color: var(--mana-libro-variable-title-color);
-        background: transparent;
-      }
-
-      .ant-input-prefix {
-        color: var(--mana-libro-variable-icon-color);
-      }
-    }
-
-    &-extra {
-      margin-left: 8px;
-      color: var(--mana-libro-variable-icon-color);
-
-      :hover {
-        color: #1890ff;
-        cursor: pointer;
-      }
-    }
-  }
-}
-
-.libro-variable-empty {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  height: 100%;
-  margin: unset !important;
-}

package/lib/browser/variables/inspector-script.d.ts

@@ -1,17 +0,0 @@
-export interface LanguageModel {
-    initScript: string;
-    queryCommand: string;
-    matrixQueryCommand: string;
-    widgetQueryCommand: string;
-    deleteCommand: string;
-}
-export declare abstract class Languages {
-    /**
-     * Init and query script for supported languages.
-     */
-    static py_script: string;
-    static r_script: string;
-    static scripts: Record<string, LanguageModel>;
-    static getScript(lang: string): Promise<LanguageModel>;
-}
-//# sourceMappingURL=inspector-script.d.ts.map

package/lib/browser/variables/inspector-script.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inspector-script.d.ts","sourceRoot":"","sources":["../../../src/browser/variables/inspector-script.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,8BAAsB,SAAS;IAC7B;;OAEG;IAEH,MAAM,CAAC,SAAS,SAuNhB;IAEA,MAAM,CAAC,QAAQ,SAqEX;IAEJ,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAoC3C;WAEY,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;CAS9D"}

package/lib/browser/variables/inspector-script.js

@@ -1,339 +0,0 @@
-export class Languages {
-    static getScript(lang) {
-        return new Promise((resolve, reject) => {
-            if (lang in Languages.scripts) {
-                resolve(Languages.scripts[lang]);
-            }
-            else {
-                reject('Language ' + lang + ' not supported yet!');
-            }
-        });
-    }
-}
-/**
- * Init and query script for supported languages.
- */
-Languages.py_script = `import json
-import sys
-from importlib import __import__
-from IPython import get_ipython
-from IPython.core.magics.namespace import NamespaceMagics
-
-
-_jupyterlab_variableinspector_nms = NamespaceMagics()
-_jupyterlab_variableinspector_Jupyter = get_ipython()
-_jupyterlab_variableinspector_nms.shell = _jupyterlab_variableinspector_Jupyter.kernel.shell
-
-__np = None
-__pd = None
-__pyspark = None
-__tf = None
-__K = None
-__torch = None
-__ipywidgets = None
-__xr = None
-
-
-def _attempt_import(module):
-    try:
-        return __import__(module)
-    except ImportError:
-        return None
-
-
-def _check_imported():
-    global __np, __pd, __pyspark, __tf, __K, __torch, __ipywidgets, __xr
-
-    __np = _attempt_import('numpy')
-    __pd = _attempt_import('pandas')
-    __pyspark = _attempt_import('pyspark')
-    __tf = _attempt_import('tensorflow')
-    __K = _attempt_import('keras.backend') or _attempt_import('tensorflow.keras.backend')
-    __torch = _attempt_import('torch')
-    __ipywidgets = _attempt_import('ipywidgets')
-    __xr = _attempt_import('xarray')
-
-
-def _jupyterlab_variableinspector_getsizeof(x):
-    if type(x).__name__ in ['ndarray', 'Series']:
-        return x.nbytes
-    elif __pyspark and isinstance(x, __pyspark.sql.DataFrame):
-        return "?"
-    elif __tf and isinstance(x, __tf.Variable):
-        return "?"
-    elif __torch and isinstance(x, __torch.Tensor):
-        return x.element_size() * x.nelement()
-    elif __pd and type(x).__name__ == 'DataFrame':
-        return x.memory_usage().sum()
-    else:
-        return sys.getsizeof(x)
-
-
-def _jupyterlab_variableinspector_getshapeof(x):
-    if __pd and isinstance(x, __pd.DataFrame):
-        return "%d rows x %d cols" % x.shape
-    if __pd and isinstance(x, __pd.Series):
-        return "%d rows" % x.shape
-    if __np and isinstance(x, __np.ndarray):
-        shape = " x ".join([str(i) for i in x.shape])
-        return "%s" % shape
-    if __pyspark and isinstance(x, __pyspark.sql.DataFrame):
-        return "? rows x %d cols" % len(x.columns)
-    if __tf and isinstance(x, __tf.Variable):
-        shape = " x ".join([str(int(i)) for i in x.shape])
-        return "%s" % shape
-    if __tf and isinstance(x, __tf.Tensor):
-        shape = " x ".join([str(int(i)) for i in x.shape])
-        return "%s" % shape
-    if __torch and isinstance(x, __torch.Tensor):
-        shape = " x ".join([str(int(i)) for i in x.shape])
-        return "%s" % shape
-    if __xr and isinstance(x, __xr.DataArray):
-        shape = " x ".join([str(int(i)) for i in x.shape])
-        return "%s" % shape
-    if isinstance(x, list):
-        return "%s" % len(x)
-    if isinstance(x, dict):
-        return "%s keys" % len(x)
-    return None
-
-
-def _jupyterlab_variableinspector_getcontentof(x):
-    # returns content in a friendly way for python variables
-    # pandas and numpy
-    if __pd and isinstance(x, __pd.DataFrame):
-        colnames = ', '.join(x.columns.map(str))
-        content = "Columns: %s" % colnames
-    elif __pd and isinstance(x, __pd.Series):
-        content = str(x.values).replace(" ", ", ")[1:-1]
-        content = content.replace("\\n", "")
-    elif __np and isinstance(x, __np.ndarray):
-        content = x.__repr__()
-    elif __xr and isinstance(x, __xr.DataArray):
-        content = x.values.__repr__()
-    else:
-        content = str(x)
-
-    if len(content) > 150:
-        return content[:150] + " ..."
-    else:
-        return content
-
-
-def _jupyterlab_variableinspector_is_matrix(x):
-    # True if type(x).__name__ in ["DataFrame", "ndarray", "Series"] else False
-    if __pd and isinstance(x, __pd.DataFrame):
-        return True
-    if __pd and isinstance(x, __pd.Series):
-        return True
-    if __np and isinstance(x, __np.ndarray) and len(x.shape) <= 2:
-        return True
-    if __pyspark and isinstance(x, __pyspark.sql.DataFrame):
-        return True
-    if __tf and isinstance(x, __tf.Variable) and len(x.shape) <= 2:
-        return True
-    if __tf and isinstance(x, __tf.Tensor) and len(x.shape) <= 2:
-        return True
-    if __torch and isinstance(x, __torch.Tensor) and len(x.shape) <= 2:
-        return True
-    if __xr and isinstance(x, __xr.DataArray) and len(x.shape) <= 2:
-        return True
-    if isinstance(x, list):
-        return True
-    return False
-
-
-def _jupyterlab_variableinspector_is_widget(x):
-    return __ipywidgets and issubclass(x, __ipywidgets.DOMWidget)
-
-
-def _jupyterlab_variableinspector_dict_list():
-    _check_imported()
-    def keep_cond(v):
-        try:
-            obj = eval(v)
-            if isinstance(obj, str):
-                return True
-            if __tf and isinstance(obj, __tf.Variable):
-                return True
-            if __pd and __pd is not None and (
-                isinstance(obj, __pd.core.frame.DataFrame)
-                or isinstance(obj, __pd.core.series.Series)):
-                return True
-            if __xr and __xr is not None and isinstance(obj, __xr.DataArray):
-                return True
-
-            if  v in ['__np', '__pd', '__pyspark', '__tf', '__K', '__torch', '__ipywidgets', '__xr']:
-                return obj is not None
-            return True
-        except:
-            return False
-    values = _jupyterlab_variableinspector_nms.who_ls()
-    vardic = [
-        {
-            'varName': _v,
-            'varType': type(eval(_v)).__name__,
-            'varSize': str(_jupyterlab_variableinspector_getsizeof(eval(_v))),
-            'varShape': str(_jupyterlab_variableinspector_getshapeof(eval(_v))) if _jupyterlab_variableinspector_getshapeof(eval(_v)) else '',
-            'varContent': str(_jupyterlab_variableinspector_getcontentof(eval(_v))),
-            'isMatrix': _jupyterlab_variableinspector_is_matrix(eval(_v)),
-            'isWidget': _jupyterlab_variableinspector_is_widget(type(eval(_v)))
-        }
-        for _v in values if keep_cond(_v)
-    ]
-    return json.dumps(vardic, ensure_ascii=False)
-
-
-def _jupyterlab_variableinspector_getmatrixcontent(x, max_rows=10000):
-    # to do: add something to handle this in the future
-    threshold = max_rows
-
-    if __pd and __pyspark and isinstance(x, __pyspark.sql.DataFrame):
-        df = x.limit(threshold).toPandas()
-        return _jupyterlab_variableinspector_getmatrixcontent(df.copy())
-    elif __np and __pd and type(x).__name__ == "DataFrame":
-        if threshold is not None:
-            x = x.head(threshold)
-        x.columns = x.columns.map(str)
-        return x.to_json(orient="table", default_handler=_jupyterlab_variableinspector_default, force_ascii=False)
-    elif __np and __pd and type(x).__name__ == "Series":
-        if threshold is not None:
-            x = x.head(threshold)
-        return x.to_json(orient="table", default_handler=_jupyterlab_variableinspector_default, force_ascii=False)
-    elif __np and __pd and type(x).__name__ == "ndarray":
-        df = __pd.DataFrame(x)
-        return _jupyterlab_variableinspector_getmatrixcontent(df)
-    elif __tf and (isinstance(x, __tf.Variable) or isinstance(x, __tf.Tensor)):
-        df = __K.get_value(x)
-        return _jupyterlab_variableinspector_getmatrixcontent(df)
-    elif __torch and isinstance(x, __torch.Tensor):
-        df = x.cpu().numpy()
-        return _jupyterlab_variableinspector_getmatrixcontent(df)
-    elif __xr and isinstance(x, __xr.DataArray):
-        df = x.to_numpy()
-        return _jupyterlab_variableinspector_getmatrixcontent(df)
-    elif isinstance(x, list):
-        s = __pd.Series(x)
-        return _jupyterlab_variableinspector_getmatrixcontent(s)
-
-
-def _jupyterlab_variableinspector_displaywidget(widget):
-    display(widget)
-
-
-def _jupyterlab_variableinspector_default(o):
-    if isinstance(o, __np.number): return int(o)
-    raise TypeError
-
-
-def _jupyterlab_variableinspector_deletevariable(x):
-    exec("del %s" % x, globals())
-`;
-Languages.r_script = `library(repr)
-
-.ls.objects = function (pos = 1, pattern, order.by, decreasing = FALSE, head = FALSE,
-    n = 5)
-{
-    napply <- function(names, fn) sapply(names, function(x) fn(get(x,
-        pos = pos)))
-    names <- ls(pos = pos, pattern = pattern)
-    if (length(names) == 0) {
-        return(jsonlite::toJSON(data.frame()))
-    }
-    obj.class <- napply(names, function(x) as.character(class(x))[1])
-    obj.mode <- napply(names, mode)
-    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
-    obj.size <- napply(names, object.size)
-    obj.dim <- t(napply(names, function(x) as.numeric(dim(x))[1:2]))
-    obj.content <- rep("NA", length(names))
-    has_no_dim <- is.na(obj.dim)[1:length(names)]
-    obj.dim[has_no_dim, 1] <- napply(names, length)[has_no_dim]
-    vec <- (obj.type != "function")
-    obj.content[vec] <- napply(names[vec], function(x) toString(x, width = 154)[1])
-
-    obj.rownames <- napply(names, rownames)
-    has_rownames <- obj.rownames != "NULL"
-    obj.rownames <- sapply(obj.rownames[has_rownames], function(x) paste(x,
-        collapse=", "))
-    obj.rownames.short <- sapply(obj.rownames, function(x) paste(substr(x, 1, 150), "...."))
-    obj.rownames <- ifelse(nchar(obj.rownames) > 154, obj.rownames.short, obj.rownames)
-    obj.rownames <- sapply(obj.rownames, function(x) paste("Row names: ",x))
-    obj.content[has_rownames] <- obj.rownames
-
-
-    obj.colnames <- napply(names, colnames)
-    has_colnames <- obj.colnames != "NULL"
-    obj.colnames <- sapply(obj.colnames[has_colnames], function(x) paste(x,
-        collapse = ", "))
-    obj.colnames.short <- sapply(obj.colnames, function(x) paste(substr(x,
-        1, 150), "...."))
-    obj.colnames <- ifelse(nchar(obj.colnames) > 154, obj.colnames.short,
-        obj.colnames)
-    obj.colnames <- sapply(obj.colnames, function(x) paste("Column names: ",x))
-
-    obj.content[has_colnames] <- obj.colnames
-
-    is_function <- (obj.type == "function")
-    obj.content[is_function] <- napply(names[is_function], function(x) paste(strsplit(repr_text(x),")")[[1]][1],")",sep=""))
-    obj.content <- unlist(obj.content, use.names = FALSE)
-
-
-    out <- data.frame(obj.type, obj.size, obj.dim)
-    names(out) <- c("varType", "varSize", "Rows", "Columns")
-    out$varShape <- paste(out$Rows, " x ", out$Columns)
-    out$varContent <- obj.content
-    out$isMatrix <- FALSE
-    out$varName <- row.names(out)
-    out <- out[, !(names(out) %in% c("Rows", "Columns"))]
-    rownames(out) <- NULL
-    print(out)
-    if (!missing(order.by))
-        out <- out[order(out[[order.by]], decreasing = decreasing),
-            ]
-    if (head)
-        out <- head(out, n)
-    jsonlite::toJSON(out)
-}
-
-.deleteVariable <- function(x) {
-    remove(list=c(x), envir=.GlobalEnv)
-}
-    `;
-Languages.scripts = {
-    python3: {
-        initScript: Languages.py_script,
-        queryCommand: '_jupyterlab_variableinspector_dict_list()',
-        matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
-        widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
-        deleteCommand: '_jupyterlab_variableinspector_deletevariable',
-    },
-    python2: {
-        initScript: Languages.py_script,
-        queryCommand: '_jupyterlab_variableinspector_dict_list()',
-        matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
-        widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
-        deleteCommand: '_jupyterlab_variableinspector_deletevariable',
-    },
-    python: {
-        initScript: Languages.py_script,
-        queryCommand: '_jupyterlab_variableinspector_dict_list()',
-        matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
-        widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
-        deleteCommand: '_jupyterlab_variableinspector_deletevariable',
-    },
-    R: {
-        initScript: Languages.r_script,
-        queryCommand: '.ls.objects()',
-        matrixQueryCommand: '.ls.objects',
-        widgetQueryCommand: 'TODO',
-        deleteCommand: '.deleteVariable',
-    },
-    scala: {
-        initScript: '_root_.almond.api.JupyterAPIHolder.value.VariableInspector.init()',
-        queryCommand: '_root_.almond.api.JupyterAPIHolder.value.VariableInspector.dictList()',
-        matrixQueryCommand: '', // TODO
-        widgetQueryCommand: '', // TODO
-        deleteCommand: '', // TODO
-    },
-};
-//# sourceMappingURL=inspector-script.js.map

package/lib/browser/variables/inspector-script.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inspector-script.js","sourceRoot":"","sources":["../../../src/browser/variables/inspector-script.ts"],"names":[],"mappings":"AAQA,MAAM,OAAgB,SAAS;IA2UtB,MAAM,CAAC,SAAS,CAAC,IAAY;QAClC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;gBAC9B,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACnC,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,WAAW,GAAG,IAAI,GAAG,qBAAqB,CAAC,CAAC;YACrD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;;AAlVD;;GAEG;AAEI,mBAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuNpB,CAAC;AAEO,kBAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqEf,CAAC;AAEG,iBAAO,GAAkC;IAC9C,OAAO,EAAE;QACP,UAAU,EAAE,SAAS,CAAC,SAAS;QAC/B,YAAY,EAAE,2CAA2C;QACzD,kBAAkB,EAAE,gDAAgD;QACpE,kBAAkB,EAAE,6CAA6C;QACjE,aAAa,EAAE,8CAA8C;KAC9D;IACD,OAAO,EAAE;QACP,UAAU,EAAE,SAAS,CAAC,SAAS;QAC/B,YAAY,EAAE,2CAA2C;QACzD,kBAAkB,EAAE,gDAAgD;QACpE,kBAAkB,EAAE,6CAA6C;QACjE,aAAa,EAAE,8CAA8C;KAC9D;IACD,MAAM,EAAE;QACN,UAAU,EAAE,SAAS,CAAC,SAAS;QAC/B,YAAY,EAAE,2CAA2C;QACzD,kBAAkB,EAAE,gDAAgD;QACpE,kBAAkB,EAAE,6CAA6C;QACjE,aAAa,EAAE,8CAA8C;KAC9D;IACD,CAAC,EAAE;QACD,UAAU,EAAE,SAAS,CAAC,QAAQ;QAC9B,YAAY,EAAE,eAAe;QAC7B,kBAAkB,EAAE,aAAa;QACjC,kBAAkB,EAAE,MAAM;QAC1B,aAAa,EAAE,iBAAiB;KACjC;IACD,KAAK,EAAE;QACL,UAAU,EAAE,mEAAmE;QAC/E,YAAY,EAAE,uEAAuE;QACrF,kBAAkB,EAAE,EAAE,EAAE,OAAO;QAC/B,kBAAkB,EAAE,EAAE,EAAE,OAAO;QAC/B,aAAa,EAAE,EAAE,EAAE,OAAO;KAC3B;CACF,CAAC"}

package/lib/browser/variables/libro-variable-color-registry.d.ts

@@ -1,6 +0,0 @@
-import { ColorContribution } from '@difizen/mana-app';
-import type { ColorRegistry } from '@difizen/mana-app';
-export declare class LibroVariableColorRegistry implements ColorContribution {
-    registerColors(colors: ColorRegistry): void;
-}
-//# sourceMappingURL=libro-variable-color-registry.d.ts.map