@opensumi/ide-notebook 3.4.5-next-1730119322.0

package/src/browser/libro/index.ts

@@ -0,0 +1,3 @@
+export * from './libro-opensumi-content-contribution';
+export * from './libro-opensumi-save-content-contribution';
+export * from './mana-module';

package/src/browser/libro/libro-opensumi-content-contribution.ts

@@ -0,0 +1,63 @@
+import { ContentContribution } from '@difizen/libro-core';
+import { IContentsModel, INotebookContent, LibroJupyterModel, NotebookOption } from '@difizen/libro-jupyter/noeditor';
+import { getOrigin, inject, singleton } from '@difizen/mana-app';
+
+import { Injector } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+import { IMessageService } from '@opensumi/ide-overlay';
+
+import { ContentLoaderType, OpensumiInjector } from '../mana';
+
+@singleton({ contrib: ContentContribution })
+export class LibroOpensumiContentContribution implements ContentContribution {
+  @inject(OpensumiInjector) injector: Injector;
+
+  canHandle = (options) => options.loadType === ContentLoaderType ? 100 : 1;
+  async loadContent(options: NotebookOption, model: LibroJupyterModel) {
+    const fileServiceClient: IFileServiceClient = this.injector.get(IFileServiceClient);
+    const messageService = this.injector.get(IMessageService);
+    let notebookContent: INotebookContent;
+    try {
+      const { content } = await getOrigin(fileServiceClient).readFile(options.resource.toString());
+      const stat = await getOrigin(fileServiceClient).getFileStat(options.resource.toString());
+      if (content.byteLength === 0) {
+        notebookContent = {
+          cells: [],
+          metadata: {},
+          nbformat: 4,
+          nbformat_minor: 5,
+        };
+      } else {
+        notebookContent = JSON.parse(content.toString());
+      }
+      const uri = new URI(options.resource.toString());
+      const currentFileContents: IContentsModel = {
+        name: uri.path.name,
+        path: uri.path.toString(),
+        last_modified: stat?.lastModification.toString() || new Date().toJSON(),
+        created: stat?.createTime?.toString() || new Date().toJSON(),
+        content: notebookContent,
+        size: stat?.size,
+        writable: true,
+        type: 'notebook',
+      };
+      model.currentFileContents = currentFileContents;
+      model.filePath = currentFileContents.path;
+      model.id = currentFileContents.path; //
+      model.lastModified = model.currentFileContents.last_modified;
+      if (model.executable) {
+        model.startKernelConnection();
+      }
+    } catch (e) {
+      messageService.error(`Notebook file ${options.resource.toString()} read error: ${e}`);
+      notebookContent = {
+        cells: [],
+        metadata: {},
+        nbformat: 4,
+        nbformat_minor: 5,
+      };
+    }
+    return notebookContent;
+  }
+}

package/src/browser/libro/libro-opensumi-save-content-contribution.ts

@@ -0,0 +1,43 @@
+import {
+  ContentSaveContribution,
+  LibroJupyterModel,
+  NotebookOption,
+  SaveFileErrorModal,
+} from '@difizen/libro-jupyter/noeditor';
+import { ModalService, URI, getOrigin, inject, singleton } from '@difizen/mana-app';
+
+import { Injector } from '@opensumi/di';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import { ContentLoaderType, OpensumiInjector } from '../mana';
+
+@singleton({ contrib: ContentSaveContribution })
+export class LibroOpensumiContentSaveContribution implements ContentSaveContribution {
+  @inject(ModalService) protected readonly modalService: ModalService;
+  @inject(OpensumiInjector) injector: Injector;
+
+  canHandle = (options: NotebookOption) => options.loadType === ContentLoaderType ? 100 : 1;
+  saveContent = async (options: NotebookOption, model: LibroJupyterModel) => {
+    const uri = new URI(options.resource.toString());
+    const fileServiceClient: IFileServiceClient = getOrigin(this.injector.get(IFileServiceClient));
+    const stat = await getOrigin(fileServiceClient).getFileStat(options.resource.toString());
+    try {
+      const notebookContent = model.toJSON();
+      if (!stat) {throw new Error('Get file stat error!');}
+      getOrigin(fileServiceClient).setContent(stat, JSON.stringify(notebookContent));
+    } catch (e: any) {
+      model.fileService.fileSaveErrorEmitter.fire({
+        cause: e.errorCause,
+        msg: e.message,
+        name: uri.path?.name || model.currentFileContents.name,
+        path: uri?.path.toString() || model.currentFileContents.path,
+        created: stat?.createTime?.toString() || model.currentFileContents.created,
+        last_modified: stat?.lastModification.toString() || model.currentFileContents.last_modified,
+        size: stat?.size || model.currentFileContents.size,
+        type: 'notebook',
+      });
+      this.modalService.openModal(SaveFileErrorModal);
+      throw new Error('File Save Error', e);
+    }
+  };
+}

package/src/browser/libro/mana-module.ts

@@ -0,0 +1,9 @@
+import { ManaModule } from '@difizen/mana-app';
+
+import { LibroOpensumiEditorModule } from './editor/module';
+import { LibroOpensumiContentContribution } from './libro-opensumi-content-contribution';
+import { LibroOpensumiContentSaveContribution } from './libro-opensumi-save-content-contribution';
+
+export const LibroOpensumiModule = ManaModule.create()
+  .register(LibroOpensumiContentContribution, LibroOpensumiContentSaveContribution)
+  .dependOn(LibroOpensumiEditorModule);

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

@@ -0,0 +1,147 @@
+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,
+  CommandRegistry,
+  Domain,
+  IContextKeyService,
+  KeybindingRegistry,
+  KeybindingScope,
+} 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)
+export class LibroKeybindContribition implements ClientAppContribution {
+  @Autowired(IContextKeyService) contextKeyService: IContextKeyService;
+  @Autowired(KeybindingRegistry) keybindingRegistry: KeybindingRegistry;
+  @Autowired(WorkbenchEditorService)
+  workbenchEditorService: WorkbenchEditorService;
+  @Autowired(CommandRegistry)
+  protected readonly commandRegistry: CommandRegistry;
+  @Autowired(ManaContainer)
+  private readonly manaContainer: Container;
+
+  onStart() {
+    this.registerContextKey();
+    this.registerCommand();
+    this.registerKeybind();
+  }
+
+  registerContextKey() {
+    const notebookFocusContext = this.contextKeyService.createKey<boolean>(
+      'libroNotebookFocused',
+      this.hasActiveNotebook(),
+    );
+
+    this.workbenchEditorService.onActiveResourceChange((e) => {
+      if (e?.uri?.path.ext === `.${LIBRO_COMPONENTS_SCHEME_ID}`) {
+        notebookFocusContext.set(true);
+      } else {
+        notebookFocusContext.set(false);
+      }
+    });
+  }
+
+  get libroService() {
+    return this.manaContainer.get(LibroService);
+  }
+
+  get libroCommandRegistry() {
+    return this.manaContainer.get(LibroCommandRegistry);
+  }
+
+  hasActiveNotebook() {
+    return this.libroService.active instanceof LibroView;
+  }
+
+  registerCommand() {
+    this.commandRegistry.registerCommand(NotebookCommands['EnterCommandMode'], {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(NotebookCommands['EnterCommandMode'].id);
+      },
+    });
+    this.commandRegistry.registerCommand(NotebookCommands['RunCell'], {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(NotebookCommands['RunCell'].id);
+      },
+    });
+    this.commandRegistry.registerCommand(NotebookCommands['RunCellAndSelectNext'], {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(NotebookCommands['RunCellAndSelectNext'].id);
+      },
+    });
+    this.commandRegistry.registerCommand(NotebookCommands['RunCellAndInsertBelow'], {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(NotebookCommands['RunCellAndInsertBelow'].id);
+      },
+    });
+    this.commandRegistry.registerCommand(NotebookCommands['SplitCellAntCursor'], {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(NotebookCommands['SplitCellAntCursor'].id);
+      },
+    });
+    this.commandRegistry.registerCommand(LibroSearchToggleCommand.ShowLibroSearch, {
+      execute: () => {
+        this.libroCommandRegistry.executeCommand(LibroSearchToggleCommand.ShowLibroSearch.id);
+      },
+    });
+  }
+
+  registerKeybind() {
+    this.keybindingRegistry.registerKeybindings(
+      [
+        {
+          keybinding: 'f1',
+          command: '',
+          when: 'libroNotebookFocused',
+        },
+        {
+          keybinding: 'f8',
+          command: '',
+          when: 'libroNotebookFocused',
+        },
+        {
+          keybinding: 'f9',
+          command: '',
+          when: 'libroNotebookFocused',
+        },
+        {
+          keybinding: 'esc',
+          command: NotebookCommands['EnterCommandMode'].id,
+          when: 'libroNotebookFocused && !editorHasSelection && !editorHasSelection && !editorHasMultipleSelections',
+        },
+        {
+          keybinding: 'ctrlcmd+enter',
+          command: NotebookCommands['RunCell'].id,
+          when: 'libroNotebookFocused && !findWidgetVisible && !referenceSearchVisible',
+        },
+        {
+          keybinding: 'shift+enter',
+          command: NotebookCommands['RunCellAndSelectNext'].id,
+          when: 'libroNotebookFocused && !findInputFocussed',
+        },
+        {
+          keybinding: 'alt+enter',
+          command: NotebookCommands['RunCellAndInsertBelow'].id,
+          when: 'libroNotebookFocused && !findWidgetVisible',
+        },
+        {
+          keybinding: 'ctrlcmd+shift+-',
+          command: NotebookCommands['SplitCellAntCursor'].id,
+          when: 'libroNotebookFocused && !findWidgetVisible',
+        },
+        {
+          keybinding: 'ctrlcmd+f',
+          command: LibroSearchToggleCommand.ShowLibroSearch.id,
+          when: 'libroNotebookFocused',
+        },
+      ],
+      KeybindingScope.USER,
+    );
+  }
+}

package/src/browser/libro-opener.ts

@@ -0,0 +1,96 @@
+import { IPosition as LibroPosition, IRange as LibroRange } from '@difizen/libro-code-editor';
+import { CellUri, EditorCellView, ExecutableNotebookModel } from '@difizen/libro-jupyter/noeditor';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { IOpener, IPosition, IRange, URI } from '@opensumi/ide-core-browser';
+import { Schemes } from '@opensumi/ide-core-common';
+
+import { LibroOpensumiService } from './libro.service';
+
+export const toEditorRange = (range: IRange): LibroRange => ({
+  start: {
+    line: range.startLineNumber - 1,
+    column: range.startColumn - 1,
+  },
+  end: {
+    line: range.endLineNumber - 1,
+    column: range.endColumn - 1,
+  },
+});
+
+export const toMonacoPosition = (position: IPosition | undefined): LibroPosition => {
+  if (!position) {
+    return {
+      column: 0,
+      line: 0,
+    };
+  }
+  return {
+    column: position?.column - 1,
+    line: position?.lineNumber - 1,
+  };
+};
+
+@Injectable()
+export class LibroOpener implements IOpener {
+  // @Autowired(ResourceService)
+  // resourceService: ResourceService;
+
+  // @Autowired(WorkbenchEditorService)
+  // workbenchEditorService: WorkbenchEditorService;
+  @Autowired(LibroOpensumiService)
+  libroOpensumiService: LibroOpensumiService;
+
+  async open(uri: URI) {
+    let range: IRange | undefined;
+    const match = /^L?(\d+)(?:,(\d+))?/.exec(uri.fragment);
+    if (match) {
+      // support file:///some/file.js#73,84
+      // support file:///some/file.js#L73
+      const startLineNumber = parseInt(match[1], 10);
+      const startColumn = match[2] ? parseInt(match[2], 10) : 1;
+      range = {
+        startLineNumber,
+        startColumn,
+        endLineNumber: startLineNumber,
+        endColumn: startColumn,
+      };
+    }
+    await this.openCell(uri, range);
+    return true;
+  }
+
+  protected async openCell(uri: URI, range?: IRange) {
+    const notebookUri = URI.file(uri.path.toString());
+    const libroView = await this.libroOpensumiService.getOrCreatLibroView(notebookUri);
+
+    if (!libroView) {
+      return false;
+    }
+
+    const cell = libroView.model.cells.find(
+      (item) =>
+        ExecutableNotebookModel.is(libroView.model) &&
+        CellUri.from(libroView.model.filePath, item.model.id).toString() === decodeURIComponent(uri.toString()),
+    );
+
+    if (!EditorCellView.is(cell)) {
+      return;
+    }
+
+    libroView.selectCell(cell);
+    let line = 0;
+    if (range) {
+      cell.editor?.focus();
+      cell.editor?.revealSelection(toEditorRange(range));
+      cell.editor?.setCursorPosition(toEditorRange(range).start);
+      line = toEditorRange(range).start.line;
+    }
+    libroView.model.scrollToView(cell, (line ?? 0) * 20);
+  }
+
+  handleScheme(scheme: string) {
+    // 使用 handleURI 后会忽略 handleScheme
+    return scheme === Schemes.notebookCell;
+  }
+}

package/src/browser/libro.color.tokens.ts

@@ -0,0 +1,32 @@
+import { localize } from '@opensumi/ide-core-browser';
+import { registerColor } from '@opensumi/ide-theme/lib/common';
+
+export const initLibroColorToken = () => {
+  registerColor(
+    'libro.background',
+    { dark: '#151b21', light: '#ffffff', hcDark: null, hcLight: null },
+    localize('libro.background', 'Background color of libroView'),
+    true,
+  );
+
+  registerColor(
+    'libro.side.toolbar.background',
+    { dark: '#20262E', light: '#ffffff', hcDark: null, hcLight: null },
+    localize('libro.side.toolbar.background', 'the side toolbar color of libro'),
+    true,
+  );
+
+  registerColor(
+    'libro.output.background',
+    { dark: '#222830', light: '#ffffff', hcDark: null, hcLight: null },
+    localize('libro.output.background', 'the output color of libro'),
+    true,
+  );
+
+  registerColor(
+    'libro.input.background',
+    { dark: '#151b21', light: '#f4f6fb', hcDark: null, hcLight: null },
+    localize('libro.input.background', 'the input color of libro'),
+    true,
+  );
+};

package/src/browser/libro.command.ts

@@ -0,0 +1,63 @@
+import { LibroSearchManager, LibroService } from '@difizen/libro-jupyter/noeditor';
+import { Container } from '@difizen/mana-app';
+
+import { Autowired } from '@opensumi/di';
+import { CommandContribution, CommandRegistry, Domain, EDITOR_COMMANDS } from '@opensumi/ide-core-browser';
+
+import { ManaContainer } from './mana';
+
+@Domain(CommandContribution)
+export class LibroCommandContribution implements CommandContribution {
+  @Autowired(ManaContainer)
+  private readonly manaContainer: Container;
+
+  registerCommands(commands: CommandRegistry): void {
+    commands.registerHandler(EDITOR_COMMANDS.SAVE_CURRENT.id, {
+      execute: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        const libro = libroService.active;
+        libro?.save();
+      },
+      isEnabled: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        if (libroService.focus) {
+          return true;
+        }
+        return false;
+      },
+    });
+    commands.registerHandler(EDITOR_COMMANDS.FOCUS_IF_NOT_ACTIVATE_ELEMENT.id, {
+      execute: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        const libro = libroService.active;
+        const libroSearchManager = this.manaContainer.get(LibroSearchManager);
+        if (libro) {
+          libroSearchManager.showSearchView(libro);
+        }
+      },
+      isEnabled: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        if (libroService.focus) {
+          return true;
+        }
+        return false;
+      },
+    });
+    commands.registerHandler('markers', {
+      execute: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        const libro = libroService.active;
+        if (libro && libro.activeCell) {
+          libro.mergeCellBelow(libro.activeCell);
+        }
+      },
+      isEnabled: () => {
+        const libroService = this.manaContainer.get(LibroService);
+        if (libroService.focus) {
+          return true;
+        }
+        return false;
+      },
+    });
+  }
+}

package/src/browser/libro.contribution.tsx

@@ -0,0 +1,189 @@
+import { LibroJupyterNoEditorModule, ServerConnection, ServerManager } from '@difizen/libro-jupyter/noeditor';
+import { LibroTOCModule } from '@difizen/libro-toc';
+import { Container, ManaAppPreset, ManaComponents, ThemeService } from '@difizen/mana-app';
+import React, { useState } from 'react';
+
+import { Autowired, Injector } from '@opensumi/di';
+import {
+  AppConfig,
+  ClientAppContextContribution,
+  ClientAppContribution,
+  CommandContribution,
+  type CommandRegistry,
+  Domain,
+  IClientApp,
+  IOpenerService,
+  OpenerContribution,
+  Schemes,
+  URI,
+} from '@opensumi/ide-core-browser';
+import {
+  BrowserEditorContribution,
+  EditorComponentRegistry,
+  IResource,
+  ResourceService,
+  WorkbenchEditorService,
+} from '@opensumi/ide-editor/lib/browser';
+import { IEditorDocumentModelContentRegistry } from '@opensumi/ide-editor/lib/browser/doc-model/types';
+import { IconService } from '@opensumi/ide-theme/lib/browser';
+import { IThemeService, IconType } from '@opensumi/ide-theme/lib/common';
+
+import { initKernelPanelColorToken } from './kernel-panel';
+import { LibroOpensumiModule } from './libro';
+import { LibroOpener } from './libro-opener';
+import { initLibroColorToken } from './libro.color.tokens';
+import { LIBRO_COMPONENTS_ID, LIBRO_COMPONENTS_SCHEME_ID } from './libro.protocol';
+import { OpensumiLibroView } from './libro.view';
+import { ManaContainer, initLibroOpensumi, manaContainer } from './mana/index';
+import { NotebookDocumentContentProvider } from './notebook-document-content-provider';
+import { initTocPanelColorToken } from './toc';
+
+const LIBRO_COMPONENTS_VIEW_COMMAND = {
+  id: 'opensumi-libro',
+};
+
+const LayoutWrapper: React.FC<React.PropsWithChildren> = ({ children }) => {
+  const [isReady, setIsReady] = useState(false);
+  return (
+    <ManaComponents.Application
+      context={{ container: manaContainer }}
+      modules={[ManaAppPreset, LibroJupyterNoEditorModule, LibroTOCModule, LibroOpensumiModule]}
+      renderChildren
+      onReady={() => setIsReady(true)}
+    >
+      {isReady ? children : 'loading'}
+    </ManaComponents.Application>
+  );
+};
+
+@Domain(
+  ClientAppContribution,
+  BrowserEditorContribution,
+  ClientAppContextContribution,
+  CommandContribution,
+  OpenerContribution,
+)
+export class LibroContribution
+  implements
+    ClientAppContribution,
+    BrowserEditorContribution,
+    ClientAppContextContribution,
+    CommandContribution,
+    OpenerContribution
+{
+  @Autowired(ManaContainer)
+  private readonly manaContainer: Container;
+
+  @Autowired(IconService)
+  protected readonly iconService: IconService;
+
+  @Autowired(WorkbenchEditorService)
+  protected readonly editorService: WorkbenchEditorService;
+
+  @Autowired(IThemeService)
+  protected readonly themeService: IThemeService;
+
+  @Autowired(NotebookDocumentContentProvider)
+  protected readonly notebookDocumentContentProvider: NotebookDocumentContentProvider;
+
+  @Autowired(LibroOpener)
+  protected readonly libroOpener: LibroOpener;
+
+  @Autowired(AppConfig)
+  config: AppConfig;
+
+  private serverManagerInited = false;
+
+  registerOpener(registry: IOpenerService): void {
+    registry.registerOpener(this.libroOpener);
+  }
+
+  initialize(app: IClientApp) {
+    initLibroOpensumi(app.injector, manaContainer);
+  }
+
+  registerClientAppContext(Layout: React.FC, injector: Injector): React.FC {
+    initLibroColorToken();
+    initKernelPanelColorToken();
+    initTocPanelColorToken();
+    return () => (
+      <LayoutWrapper>
+        <Layout />
+      </LayoutWrapper>
+    );
+  }
+
+  registerCommands(registry: CommandRegistry) {
+    registry.registerCommand(LIBRO_COMPONENTS_VIEW_COMMAND, {
+      execute: () => {
+        this.editorService.open(new URI(`${LIBRO_COMPONENTS_SCHEME_ID}://`), {
+          preview: false,
+        });
+      },
+    });
+  }
+
+  registerEditorComponent(registry: EditorComponentRegistry) {
+    registry.registerEditorComponent({
+      uid: LIBRO_COMPONENTS_ID,
+      scheme: LIBRO_COMPONENTS_SCHEME_ID,
+      component: OpensumiLibroView,
+    });
+
+    registry.registerEditorComponentResolver(Schemes.file, (resource, results) => {
+      if (resource.uri.path.ext === `.${LIBRO_COMPONENTS_SCHEME_ID}`) {
+        // 首次打开 notebook 文件时初始化 jupyter 服务连接
+        if (!this.serverManagerInited && this.config.notebookServerHost) {
+          this.serverManagerInited = true;
+          // 目前直接从浏览器连接 jupyter 服务，对服务的cors等配置会有要求
+          this.connectJupyterServer(this.config.notebookServerHost);
+        }
+        results.push({
+          type: 'component',
+          componentId: LIBRO_COMPONENTS_ID,
+        });
+      }
+    });
+  }
+
+  registerEditorDocumentModelContentProvider(registry: IEditorDocumentModelContentRegistry) {
+    registry.registerEditorDocumentModelContentProvider(this.notebookDocumentContentProvider);
+  }
+
+  registerResource(service: ResourceService) {
+    service.registerResourceProvider({
+      scheme: LIBRO_COMPONENTS_SCHEME_ID,
+      provideResource: async (uri: URI): Promise<IResource<any>> => {
+        const iconClass = this.iconService.fromIcon(
+          '',
+          'https://mdn.alipayobjects.com/huamei_xt20ge/afts/img/A*LDFvSptm_zgAAAAAAAAAAAAADiuUAQ/original',
+          IconType.Background,
+        );
+        return {
+          uri,
+          name: 'notebook',
+          icon: iconClass!,
+        };
+      },
+    });
+  }
+
+  async onDidStart() {
+    const manaThemeService = this.manaContainer.get(ThemeService);
+    const curTheme = await this.themeService.getCurrentTheme();
+    manaThemeService.setCurrentTheme(curTheme.type);
+    this.themeService.onThemeChange((theme) => {
+      manaThemeService.setCurrentTheme(theme.type);
+    });
+  }
+
+  protected connectJupyterServer(serverHost: string) {
+    const libroServerConnection = this.manaContainer.get(ServerConnection);
+    libroServerConnection.updateSettings({
+      baseUrl: `http://${serverHost}/`,
+      wsUrl: `ws://${serverHost}/`,
+    });
+    const serverManager = this.manaContainer.get(ServerManager);
+    serverManager.launch();
+  }
+}

package/src/browser/libro.module.less

@@ -0,0 +1,40 @@
+.libroView {
+  height: 100%;
+
+  :global {
+    .libro-view {
+      background-color: var(--libro-background);
+
+      .cm-editor,
+      .cm-gutters {
+        background-color: var(--libro-input-background);
+      }
+    }
+
+    .libro-cell-right-toolbar {
+      background-color: var(--libro-side-toolbar-background);
+    }
+
+    .libro-cell-output-container {
+      background-color: var(--libro-output-background);
+    }
+
+    .libro-cell-container,
+    .libro-input-hidden {
+      background-color: var(--libro-input-background);
+    }
+
+    .libro-e2-editor-container {
+      background-color: var(--libro-input-background) !important;
+    }
+
+    .libro-e2-editor {
+      background: var(--mana-libro-input-background) !important;
+
+      .monaco-editor-background,
+      .margin {
+        background: var(--libro-input-background) !important;
+      }
+    }
+  }
+}

package/src/browser/libro.protocol.ts

@@ -0,0 +1,2 @@
+export const LIBRO_COMPONENTS_ID = 'opensumi:libro';
+export const LIBRO_COMPONENTS_SCHEME_ID = 'ipynb';