常用扩展点#

JupyterLab 的大多数组件部分都设计为可扩展的，它们提供可以通过令牌在扩展中请求的服务。扩展作者可以请求的常用核心令牌列表在核心插件中给出。

在核心令牌列表之后，是使用 JupyterLab 一些最常用的扩展点的指南。但是，它不是如何扩展应用程序组件的详尽说明，其公共 API 的更详细描述可以在 JupyterLab 和 Lumino API 文档中找到。

核心插件 #

JupyterLab 的核心包提供以下插件。可以使用命令 jupyter labextension enable <plugin-id> 或 jupyter labextension disable <plugin-id> 启用或禁用它们。

@jupyterlab/javascript-extension:factory: 添加 JavaScript 内容的渲染器。
@jupyterlab/json-extension:factory: 添加 JSON 内容的渲染器。
@jupyterlab/json-lines-extension:factory: 添加 JSONLines 内容的渲染器。
@jupyterlab/mermaid-extension:factory: 为基于文本的 mermaid 图表提供渲染器。
@jupyterlab/pdf-extension:factory: 添加 PDF 内容的渲染器。
@jupyterlab/vega5-extension:factory: 为 Vega 5 和 Vega-Lite 3 到 5 内容提供渲染器。
@jupyterlab/application:mimedocument: 提供 mime 文档小部件跟踪器。
@jupyterlab/application-extension:context-menu: 填充上下文菜单。
@jupyterlab/application-extension:dirty: 在关闭带有未保存修改的浏览器选项卡时添加保护对话框。
@jupyterlab/application-extension:main: 初始化应用程序并提供 URL 树路径处理程序。
@jupyterlab/application-extension:commands: 添加与 shell 相关的命令。
@jupyterlab/application-extension:layout: 提供 shell 布局恢复器。
@jupyterlab/application-extension:router: 提供 URL 路由器
@jupyterlab/application-extension:tree-resolver: 提供树路由解析器
@jupyterlab/application-extension:notfound: 定义了未找到 URL（又称路由）的行为。
@jupyterlab/application-extension:faviconbusy: 根据应用程序状态处理 favicon。
@jupyterlab/application-extension:shell: 提供 JupyterLab shell。它具有比 app.shell 更扩展的 API。
@jupyterlab/application-extension:status: 提供应用程序状态。
@jupyterlab/application-extension:info: 提供应用程序信息。
@jupyterlab/application-extension:mode-switch: 添加界面模式切换。
@jupyterlab/application-extension:paths: 提供应用程序路径。
@jupyterlab/application-extension:property-inspector: 提供属性检查器。
@jupyterlab/application-extension:logo: 设置应用程序徽标。
@jupyterlab/application-extension:top-bar: 在顶部区域（主菜单栏旁边）添加工具栏。
@jupyterlab/apputils-extension:announcements: 添加公告功能。它将从互联网获取新闻并检查应用程序更新。
@jupyterlab/apputils-extension:kernel-status: 提供内核状态指示器模型。
@jupyterlab/apputils-extension:notification: 添加通知中心及其状态指示器。
@jupyterlab/apputils-extension:palette: 提供命令面板。
@jupyterlab/apputils-extension:palette-restorer: 恢复命令面板。
@jupyterlab/apputils-extension:print: 添加打印功能。
@jupyterlab/apputils-extension:resolver: 提供窗口名称解析器。
@jupyterlab/apputils-extension:running-sessions-status: 添加运行的会话和终端状态栏项目。
@jupyterlab/apputils-extension:sanitizer: 提供 HTML 净化器。
@jupyterlab/apputils-extension:settings: 提供设置注册表。
@jupyterlab/apputils-extension:state: 提供应用程序状态。它存储在每个工作区中。
@jupyterlab/apputils-extension:splash: 提供启动画面。
@jupyterlab/apputils-extension:sessionDialogs: 提供会话上下文对话框。
@jupyterlab/apputils-extension:themes: 提供主题管理器。
@jupyterlab/apputils-extension:themes-palette-menu: 在菜单和命令面板中添加主题命令。
@jupyterlab/apputils-extension:toggle-header: 添加一个命令来显示主区域小部件内容标题。
@jupyterlab/apputils-extension:toolbar-registry: 提供工具栏项目注册表。
@jupyterlab/apputils-extension:utilityCommands: 添加元命令来运行一组其他命令。
@jupyterlab/apputils-extension:workspaces: 添加工作区文件类型。
@jupyterlab/cell-toolbar-extension:plugin: 添加单元格工具栏。
@jupyterlab/celltags-extension:plugin: 添加单元格标签编辑器。
@jupyterlab/codemirror-extension:commands: 注册作用于选定/活动 CodeMirror 编辑器的命令。
@jupyterlab/codemirror-extension:languages: 提供 CodeMirror 语言注册表。
@jupyterlab/codemirror-extension:themes: 提供 CodeMirror 主题注册表。
@jupyterlab/codemirror-extension:binding: 注册 CodeMirror 扩展工厂，绑定编辑器和共享模型。
@jupyterlab/codemirror-extension:extensions: 提供 CodeMirror 扩展工厂注册表。
@jupyterlab/codemirror-extension:services: 提供用于实例化 CodeMirror 编辑器的服务。
@jupyterlab/codemirror-extension:line-col-status: 提供代码编辑器光标位置模型。
@jupyterlab/completer-extension:manager: 提供完成提供程序管理器。
@jupyterlab/completer-extension:base-service: 添加上下文和内核完成提供程序。
@jupyterlab/completer-extension:inline-history: 添加内联完成提供程序，建议来自执行历史记录的代码。
@jupyterlab/completer-extension:inline-completer-factory: 提供内联完成程序的工厂。
@jupyterlab/completer-extension:inline-completer: 提供内联完成程序的工厂。
@jupyterlab/console-extension:factory: 提供控制台小部件内容工厂。
@jupyterlab/console-extension:tracker: 提供控制台小部件跟踪器。
@jupyterlab/console-extension:foreign: 将 IOPub 消息的外部处理程序添加到控制台。
@jupyterlab/console-extension:kernel-status: 将控制台添加到内核状态指示器模型。
@jupyterlab/console-extension:cursor-position: 将控制台添加到代码编辑器光标位置模型。
@jupyterlab/console-extension:completer: 将完成添加到控制台。
@jupyterlab/console-extension:cell-executor: 提供控制台单元格执行器。
@jupyterlab/csvviewer-extension:csv: 添加 CSV 文件类型的查看器。
@jupyterlab/csvviewer-extension:tsv: 添加 TSV 文件类型的查看器。
@jupyterlab/debugger-extension:service: 提供调试器服务。
@jupyterlab/debugger-extension:consoles: 将调试器功能添加到控制台。
@jupyterlab/debugger-extension:files: 将调试器功能添加到文件。
@jupyterlab/debugger-extension:notebooks: 将调试器功能添加到笔记本，并提供调试器笔记本处理程序。
@jupyterlab/debugger-extension:variables: 在调试器变量面板中添加变量渲染器和检查。
@jupyterlab/debugger-extension:sidebar: 提供调试器侧边栏。
@jupyterlab/debugger-extension:main: 初始化调试器用户界面。
@jupyterlab/debugger-extension:sources: 提供调试的源代码功能。
@jupyterlab/debugger-extension:source-viewer: 初始化调试器源代码查看器。
@jupyterlab/debugger-extension:config: 提供调试器配置。
@jupyterlab/docmanager-extension:manager: 提供文档管理器。
@jupyterlab/docmanager-extension:plugin: 将命令和设置添加到文档管理器。
@jupyterlab/docmanager-extension:contexts: 添加对打开文档脏状态的处理。
@jupyterlab/docmanager-extension:path-status: 在状态栏中添加文件路径指示器。
@jupyterlab/docmanager-extension:saving-status: 添加保存状态指示器。
@jupyterlab/docmanager-extension:download: 添加下载文件的命令。
@jupyterlab/docmanager-extension:open-browser-tab: 添加打开浏览器选项卡的命令。
@jupyterlab/docmanager-extension:opener: 提供小部件打开器。
@jupyterlab/docmanager-extension:recents: 提供最近打开和关闭文档的管理器。
@jupyterlab/documentsearch-extension:plugin: 提供文档搜索注册表。
@jupyterlab/documentsearch-extension:labShellWidgetListener: 对有效文档进行主动搜索。
@jupyterlab/extensionmanager-extension:plugin: 添加扩展管理器插件。
@jupyterlab/filebrowser-extension:factory: 提供文件浏览器工厂。
@jupyterlab/filebrowser-extension:default-file-browser: 提供默认文件浏览器。
@jupyterlab/filebrowser-extension:browser: 设置默认文件浏览器（命令、设置等）。
@jupyterlab/filebrowser-extension:share-file: 添加“复制可共享链接”命令；例如，在 JupyterHub 部署中很有用。
@jupyterlab/filebrowser-extension:file-upload-status: 添加文件上传状态小部件。
@jupyterlab/filebrowser-extension:download: 添加下载文件命令。禁用此插件不会禁用从服务器下载文件，如果用户输入了相应的下载 URL。
@jupyterlab/filebrowser-extension:widget: 将文件浏览器添加到应用程序外壳。
@jupyterlab/filebrowser-extension:open-with: 添加“使用打开”功能，允许用户选择非首选文档查看器。
@jupyterlab/filebrowser-extension:open-browser-tab: 添加“在新浏览器选项卡中打开”功能。
@jupyterlab/filebrowser-extension:open-url: 添加“从远程 URL 打开文件”功能。
@jupyterlab/fileeditor-extension:plugin: 提供文件编辑器小部件跟踪器。
@jupyterlab/fileeditor-extension:cursor-position: 添加文件编辑器光标位置状态小部件。
@jupyterlab/fileeditor-extension:completer: 为文件编辑器添加自动完成功能。
@jupyterlab/fileeditor-extension:language-server: 为文件编辑器添加语言服务器功能。
@jupyterlab/fileeditor-extension:search: 为文件编辑器添加搜索功能。
@jupyterlab/fileeditor-extension:editor-syntax-status: 添加文件编辑器语法状态小部件。
@jupyterlab/fileeditor-extension:tab-space-status: 添加文件编辑器缩进状态小部件。
@jupyterlab/help-extension:about: 添加“关于”对话框功能。
@jupyterlab/help-extension:jupyter-forum: 添加打开 Jupyter 论坛网站的命令。
@jupyterlab/help-extension:open: 添加命令以将网站打开为面板或浏览器选项卡。
@jupyterlab/help-extension:resources: 添加指向 Jupyter 参考文档网站的菜单项。
@jupyterlab/help-extension:licenses: 添加使用报告工具的许可证。
@jupyterlab/htmlviewer-extension:plugin: 添加 HTML 文件查看器并提供其跟踪器。
@jupyterlab/hub-extension:plugin: 注册与集线器服务器相关的命令。
@jupyterlab/hub-extension:menu: 将与集线器相关的命令添加到菜单中。
@jupyterlab/hub-extension:connectionlost: 提供一项服务，以便在与集线器服务器的连接丢失时收到通知。
@jupyterlab/imageviewer-extension:plugin: 添加图像查看器并提供其跟踪器。
@jupyterlab/inspector-extension:inspector: 提供代码内省小部件。
@jupyterlab/inspector-extension:consoles: 为控制台添加代码内省支持。
@jupyterlab/inspector-extension:notebooks: 为笔记本添加代码内省功能。
@jupyterlab/launcher-extension:plugin: 提供启动器选项卡服务。
@jupyterlab/logconsole-extension:plugin: 提供日志记录器注册表。
@jupyterlab/lsp-extension:plugin: 提供语言服务器连接管理器。
@jupyterlab/lsp-extension:feature: 提供语言服务器功能管理器。
@jupyterlab/lsp-extension:settings: 提供语言服务器设置。
@jupyterlab/lsp:ILSPCodeExtractorsManager: 提供代码提取器管理器。
@jupyterlab/lsp-extension:tracker: 提供 WidgetLSPAdapter 的跟踪器。
@jupyterlab/mainmenu-extension:plugin: 添加并提供应用程序主菜单。
@jupyterlab/mainmenu-extension:recents: 在主菜单的“文件”部分添加打开最近文档的子菜单。
@jupyterlab/markdownviewer-extension:plugin: 添加 Markdown 文件查看器并提供其跟踪器。
@jupyterlab/markedparser-extension:plugin: 提供 Markdown 解析器。
@jupyterlab/mathjax-extension:plugin: 提供 LaTeX 数学表达式解释器。
@jupyterlab/mermaid-extension:core: 提供 Mermaid 管理器。
@jupyterlab/mermaid-extension:markdown: 提供 Mermaid Markdown 渲染器。
@jupyterlab/mermaid-extension:context-commands: 为 Mermaid 图表提供上下文菜单命令。
@jupyterlab/metadataform-extension:metadataforms: 提供元数据表单注册表。
@jupyterlab/notebook-extension:cell-executor: 提供笔记本单元格执行器。
@jupyterlab/notebook-extension:factory: 提供笔记本单元格工厂。
@jupyterlab/notebook-extension:tracker: 提供笔记本小部件跟踪器。
@jupyterlab/notebook-extension:execution-indicator: 添加笔记本执行状态小部件。
@jupyterlab/notebook-extension:export: 添加导出笔记本命令。
@jupyterlab/notebook-extension:tools: 提供笔记本工具。
@jupyterlab/notebook-extension:mode-status: 添加笔记本模式状态小部件。
@jupyterlab/notebook-extension:trust-status: 添加笔记本信任状态小部件。
@jupyterlab/notebook-extension:widget-factory: 提供笔记本小部件工厂。
@jupyterlab/notebook-extension:log-output: 将单元格输出日志添加到应用程序日志记录器。
@jupyterlab/notebook-extension:cloned-outputs: 添加克隆输出功能。
@jupyterlab/notebook-extension:code-console: 添加笔记本代码控制台功能。
@jupyterlab/notebook-extension:copy-output: 添加复制单元格输出功能。
@jupyterlab/notebook-extension:kernel-status: 添加笔记本内核状态。
@jupyterlab/notebook-extension:cursor-position: 添加笔记本光标位置状态。
@jupyterlab/notebook-extension:completer: 为笔记本添加代码补全功能。
@jupyterlab/notebook-extension:search: 为笔记本添加搜索功能。
@jupyterlab/notebook-extension:toc: 为笔记本添加目录功能。
@jupyterlab/notebook-extension:language-server: 为笔记本添加语言服务器功能。
@jupyterlab/notebook-extension:update-raw-mimetype: 添加用于原始单元格 MIME 类型的元数据表单编辑器。
@jupyterlab/notebook-extension:metadata-editor: 添加用于完整元数据编辑器的元数据表单。
@jupyterlab/notebook-extension:active-cell-tool: 在元数据编辑器选项卡中添加活动单元格字段。
@jupyterlab/pluginmanager-extension:plugin: 启用或禁用单个插件。
@jupyterlab/rendermime-extension:plugin: 提供渲染 MIME 注册表。
@jupyterlab/running-extension:plugin: 提供运行会话管理器。
@jupyterlab/running-extension:sidebar: 提供运行会话侧边栏。
@jupyterlab/running-extension:recently-closed: 添加最近关闭的文档列表。
@jupyterlab/running-extension:search-tabs: 添加一个用于搜索打开和关闭标签的小部件。
@jupyterlab/settingeditor-extension:form-ui: 添加交互式设置编辑器并提供其跟踪器。
@jupyterlab/settingeditor-extension:plugin: 添加 JSON 设置编辑器并提供其跟踪器。
@jupyterlab/shortcuts-extension:shortcuts: 添加键盘快捷键编辑器。
@jupyterlab/statusbar-extension:plugin: 提供应用程序状态栏。
@jupyterlab/terminal-extension:plugin: 添加终端并提供其跟踪器。
@jupyterlab/theme-dark-extension:plugin: 添加深色主题。
@jupyterlab/theme-dark-high-contrast-extension:plugin: 添加深色高对比度主题。
@jupyterlab/theme-light-extension:plugin: 添加浅色主题。
@jupyterlab/toc-extension:registry: 提供目录注册表。
@jupyterlab/toc-extension:tracker: 添加目录小部件并提供其跟踪器。
@jupyterlab/tooltip-extension:manager: 提供工具提示管理器。
@jupyterlab/tooltip-extension:consoles: 为控制台添加工具提示功能。
@jupyterlab/tooltip-extension:notebooks: 为笔记本添加工具提示功能。
@jupyterlab/tooltip-extension:files: 为文件编辑器添加工具提示功能。
@jupyterlab/translation:translator: 提供应用程序翻译对象。
@jupyterlab/translation-extension:plugin: 添加翻译命令和设置。
@jupyterlab/ui-components-extension:labicon-manager: 提供图标管理器。
@jupyterlab/ui-components-extension:form-renderer-registry: 提供设置表单渲染器注册表。
@jupyterlab/workspaces-extension:model: 为可用工作区提供模型。
@jupyterlab/workspaces:commands: 添加工作区命令。
@jupyterlab/workspaces-extension:sidebar: 使用工作区填充运行侧边栏。
@jupyterlab/workspaces-extension:menu: 使用工作区子菜单填充“文件”主菜单。

核心令牌 #

JupyterLab 的核心包为插件提供了许多服务。这些服务的令牌列于此处，以及您可能希望在扩展中使用这些服务的简短描述。

@jupyterlab/application:IMimeDocumentTracker: 用于使用 mime 渲染器扩展渲染的文档的小部件跟踪器。如果您想列出和交互由此类扩展渲染的文档，请使用此项。
@jupyterlab/application:ITreePathUpdater: 用于更新树路径的服务。
@jupyterlab/application:ILayoutRestorer: 提供应用程序布局恢复功能的服务。使用此功能可以跨页面加载恢复您的活动。
@jupyterlab/application:IRouter: 应用程序使用的 URL 路由器。使用此功能为您的扩展添加自定义 URL 路由（例如，如果用户导航到子路径，则调用命令）。
@jupyterlab/application:ITreeResolver: 用于解析树路径的服务。
@jupyterlab/application:ILabShell: 用于与 JupyterLab shell 交互的服务。顶层 application 对象也包含对 shell 的引用，但它具有受限的接口，以便对应用程序上不同 shell 实现保持独立。使用它来获取有关当前活动小部件和布局状态的更多详细信息。
@jupyterlab/application:ILabStatus: 用于与应用程序繁忙/脏状态交互的服务。如果您想设置应用程序“繁忙”的收藏夹图标，或设置应用程序“脏”状态，这将要求用户在离开应用程序页面之前确认，请使用此服务。
@jupyterlab/application:IInfo: 提供有关当前应用程序的元数据的服务，包括禁用的扩展和是否启用了开发模式。
@jupyterlab/application:IPaths: 提供有关当前应用程序的各种 URL 和服务器路径的信息的服务。如果您想组装 URL 以使用 JupyterLab REST API，请使用此服务。
@jupyterlab/property-inspector:IPropertyInspectorProvider: 用于在属性检查器侧边栏中注册新小部件的服务。
@jupyterlab/apputils:IKernelStatusModel: 用于将内核会话提供程序注册到内核状态指示器中的服务。
@jupyterlab/apputils:ICommandPalette: 用于左侧面板中的应用程序命令面板的服务。使用它将命令添加到面板。
@jupyterlab/apputils:IWindowResolver: 用于应用程序的窗口解析器的服务。JupyterLab 工作区被赋予一个名称，该名称使用窗口解析器确定。如果您想使用当前工作区的名称，请要求此服务。
@jupyterlab/apputils:ISanitizer: 用于清理 HTML 字符串的服务。
@jupyterlab/coreutils:ISettingRegistry: 用于 JupyterLab 设置系统的服务。如果您想为您的应用程序存储设置，请使用此服务。有关更多信息，请参见“schemaDir”。
@jupyterlab/coreutils:IStateDB: 用于 JupyterLab 状态数据库的服务。如果您想存储将在页面加载之间持久化的数据，请使用此服务。有关更多信息，请参见“状态数据库”。
@jupyterlab/apputils:ISplashScreen: 用于应用程序的启动屏幕的服务。如果您想出于自己的目的显示启动屏幕，请使用此服务。
@jupyterlab/apputils:ISessionContextDialogs: 用于处理会话对话框的服务。
@jupyterlab/apputils:IThemeManager: 用于应用程序的主题管理器的服务。这主要用于主题扩展来注册新主题。
@jupyterlab/apputils:IToolbarWidgetRegistry: 工具栏小部件的注册表。如果您想从数据定义（例如存储在设置中）动态构建工具栏，请要求此服务。
@jupyterlab/codemirror:IEditorLanguageRegistry: CodeMirror 语言的注册表。
@jupyterlab/codemirror:IEditorThemeRegistry: CodeMirror 主题的注册表。
@jupyterlab/codemirror:IEditorExtensionRegistry: CodeMirror 扩展工厂的注册表。
@jupyterlab/codeeditor:IEditorServices: 用于应用程序的文本编辑器提供者的服务。使用它来创建新的文本编辑器并将它们托管在您的 UI 元素中。
@jupyterlab/codeeditor:IPositionModel: 用于处理代码编辑器光标位置的服务。
@jupyterlab/completer:ICompletionProviderManager: 用于完成提供者管理的服务。
@jupyterlab/completer:IInlineCompleterFactory: 内联完成小部件的工厂。
@jupyterlab/console:IContentFactory: 创建新的代码控制台的工厂对象。如果您想在自己的 UI 元素中创建和托管代码控制台，请使用此服务。
@jupyterlab/console:IConsoleTracker: 代码控制台的部件跟踪器。如果您想遍历和交互由应用程序创建的代码控制台，请使用此跟踪器。
@jupyterlab/console:IConsoleCellExecutor: 控制台单元执行器。
@jupyterlab/debugger:IDebugger: 调试器用户界面。
@jupyterlab/debugger:IDebuggerHandler: 处理笔记本调试器的服务。
@jupyterlab/debugger:IDebuggerSidebar: 调试器侧边栏服务。
@jupyterlab/debugger:IDebuggerSources: 在调试模式下显示源代码的服务。
@jupyterlab/debugger:IDebuggerSourceViewer: 调试器源代码查看器。
@jupyterlab/debugger:IDebuggerConfig: 处理调试器配置的服务。
@jupyterlab/docmanager:IDocumentManager: 应用程序使用的所有文档的管理器服务。如果您想打开和关闭文档、创建和删除文件以及与文件系统进行其他交互，请使用此服务。
@jupyterlab/docmanager:IDocumentWidgetOpener: 打开部件的服务。
@jupyterlab/docmanager:IRecentsManager: 提供有关最近打开和关闭文档的信息的服务。
@jupyterlab/documentsearch:ISearchProviderRegistry: 应用程序搜索提供程序注册表服务。插件可以将它们的 UI 元素注册到此注册表中以提供查找/替换支持。
@jupyterlab/filebrowser:IFileBrowserFactory: 创建文件浏览器的工厂对象。如果您想创建自己的文件浏览器（例如，用于自定义存储后端），或者与扩展创建的其他文件浏览器进行交互，请使用此工厂对象。
@jupyterlab/filebrowser:IDefaultFileBrowser: 默认文件浏览器的服务。
@jupyterlab/filebrowser:IFileBrowserCommands: 确保文件浏览器命令加载的令牌。
@jupyterlab/fileeditor:IEditorTracker: 文件编辑器的部件跟踪器。如果您想遍历和交互由应用程序创建的文件编辑器，请使用此跟踪器。
@jupyterlab/htmlviewer:IHTMLViewerTracker: 渲染的 HTML 文档的部件跟踪器。如果您想遍历和交互由应用程序查看的 HTML 文档，请使用此跟踪器。
@jupyterlab/application:IConnectionLost: 当 JupyterLab 失去与服务器的连接时调用显示对话框的服务。如果您出于某种原因想在新的情况下显示“连接丢失”对话框，请使用此服务。
@jupyterlab/imageviewer:IImageTracker: 图像的部件跟踪器。如果您想遍历和交互由应用程序查看的图像，请使用此跟踪器。
@jupyterlab/inspector:IInspector: 为部件添加上下文帮助的服务（使用“显示上下文帮助”从帮助菜单中可见）。使用此服务将您的扩展挂钩到上下文帮助系统。
@jupyterlab/launcher:ILauncher: 应用程序活动启动器的服务。使用此服务将您的扩展活动添加到启动器面板。
@jupyterlab/logconsole:ILoggerRegistry: 提供日志记录基础设施的服务。
@jupyterlab/lsp:ILSPDocumentConnectionManager: 提供虚拟文档和语言服务器连接服务。
@jupyterlab/lsp:ILSPFeatureManager: 提供语言服务器功能管理器。此令牌是注册新客户端功能所必需的。
@jupyterlab/lsp:ILSPCodeExtractorsManager: 提供代码提取器管理器。此令牌是您的扩展中注册代码提取器所必需的，允许从打开的文档创建多个虚拟文档。
@jupyterlab/lsp:IWidgetLSPAdapterTracker: 提供 WidgetLSPAdapter 跟踪器。此令牌是您的扩展中跟踪 WidgetLSPAdapters 所必需的。
@jupyterlab/mainmenu:IMainMenu: 应用程序主菜单栏的服务。如果您想添加自己的菜单项或为特定活动提供标准化菜单项的实现，请使用此服务。
@jupyterlab/markdownviewer:IMarkdownViewerTracker: Markdown 文档查看器的窗口小部件跟踪器。如果您想遍历和交互渲染的 Markdown 文档，请使用此服务。
@jupyterlab/rendermime:IMarkdownParser: 用于将 Markdown 语法渲染为 HTML 内容的服务。
@jupyterlab/rendermime:ILatexTypesetter: 应用程序 LaTeX 排版器的服务。如果您想在扩展中排版数学公式，请使用此服务。
@jupyterlab/mermaid:IMermaidManager: 用于渲染 Mermaid 文本型图表管理器。
@jupyterlab/mermaid:IMermaidMarkdown: 用于在 Markdown 围栏代码块中渲染 Mermaid 文本型图表的管理器。
@jupyterlab/metadataform:IMetadataFormProvider: 用于注册新的元数据编辑器窗口小部件的服务。
@jupyterlab/notebook:INotebookCellExecutor: 笔记本单元格执行器。
@jupyterlab/notebook:IContentFactory: 用于创建新笔记本的工厂对象。如果您想在自己的 UI 元素中创建和托管笔记本，请使用此服务。
@jupyterlab/notebook:INotebookTracker: 笔记本的窗口小部件跟踪器。如果您想能够遍历和交互应用程序创建的笔记本，请使用此服务。
@jupyterlab/notebook:INotebookTools: 右侧边栏中“笔记本工具”面板的服务。使用此服务将您自己的功能添加到面板中。
@jupyterlab/notebook:INotebookWidgetFactory: 用于创建笔记本查看器的服务。
@jupyterlab/pluginmanager:IPluginManager: 插件管理器存在的预警，其中包含一个用于打开插件管理器窗口小部件的方法。
@jupyterlab/rendermime:IRenderMimeRegistry: 应用程序 rendermime 注册表的服务。使用此服务为扩展中的各种 MIME 类型创建渲染器。很多时候，创建“MIME 渲染器扩展”比直接使用此服务更容易。
@jupyterlab/running:IRunningSessionManagers: 用于添加运行会话管理器的服务。
@jupyterlab/running:IRunningSessionsSidebar: 用于修改运行会话侧边栏的令牌。
@jupyterlab/settingeditor:ISettingEditorTracker: 交互式设置编辑器的窗口小部件跟踪器。如果您想能够遍历和交互应用程序创建的设置编辑器，请使用此服务。
@jupyterlab/settingeditor:IJSONSettingEditorTracker: JSON 设置编辑器的窗口小部件跟踪器。如果您想能够遍历和交互应用程序创建的设置编辑器，请使用此服务。
@jupyterlab/statusbar:IStatusBar: 应用程序状态栏的服务。如果您想添加新的状态栏项目，请使用此服务。
@jupyterlab/terminal:ITerminalTracker: 终端的窗口小部件跟踪器。如果您想能够遍历和交互应用程序创建的终端，请使用此服务。
@jupyterlab/toc:ITableOfContentsRegistry: 用于注册目录工厂的服务。
@jupyterlab/toc:ITableOfContentsTracker: 目录的窗口小部件跟踪器。
@jupyterlab/tooltip:ITooltipManager: 应用程序工具提示管理器的服务。使用此服务允许您的扩展调用工具提示。
@jupyterlab/translation:ITranslator: 用于翻译字符串的服务。
@jupyterlab/ui-components:ILabIconManager: 用于注册和请求图标的服务。
@jupyterlab/ui-components:IFormRendererRegistry: 用于设置表单渲染器注册的服务。
@jupyterlab/workspaces:IWorkspacesModel: 提供可用工作区的模型。
@jupyterlab/workspaces:IWorkspaceCommands: 提供工作区命令的标识符。

命令 #

将命令添加到命令注册表#

也许向 JupyterLab 添加功能最常见的方式是通过命令。这些是轻量级对象，包括要执行的函数以及其他元数据，包括它们的标签和何时启用。应用程序有一个单一的命令注册表，以字符串命令 ID 为键，您可以将自定义命令添加到其中。

添加到命令注册表中的命令可以用于填充 JupyterLab 用户界面的多个元素，包括菜单和启动器。

以下是一个代码示例，它将一个命令添加到应用程序（由 app 给出）。

const commandID = 'my-command';
let toggled = false;

app.commands.addCommand(commandID, {
  label: 'My Cool Command',
  isEnabled: () => true,
  isVisible: () => true,
  isToggled: () => toggled,
  iconClass: 'some-css-icon-class',
  execute: () => {
    console.log(`Executed ${commandID}`);
    toggled = !toggled;
});

此示例添加了一个新命令，该命令在触发时会调用 execute 函数。 isEnabled 指示命令是否启用，并决定其渲染是否为灰色。 isToggled 指示是否在命令旁边渲染一个复选标记。 isVisible 指示是否渲染命令。 iconClass 指定一个 CSS 类，该类可用于在命令的渲染旁边显示一个图标。

每个 isEnabled、isToggled 和 isVisible 可以是布尔值或返回布尔值的函数，如果您想进行一些逻辑以确定这些条件。

同样，每个 label 和 iconClass 可以是字符串值或返回字符串值的函数。

在将新命令添加到命令注册表时，可以传递多个选项。这些选项在这里有记录。

将命令添加到应用程序命令注册表后，您可以将它们添加到应用程序用户界面的各个位置，在那里它们将使用您提供的元数据进行渲染。

例如，您可以使用 CommandToolbarButtonComponent 将一个按钮添加到笔记本工具栏以运行命令。

将命令添加到命令面板#

为了将已注册的命令添加到命令面板，您需要在扩展程序中请求 ICommandPalette 令牌。以下是一个示例，展示了如何将命令添加到命令面板（由 palette 给出）。

palette.addItem({
  command: commandID,
  category: 'my-category',
  args: {}
});

命令 ID 与您注册命令时使用的 ID 相同。您还必须提供一个 category，它决定渲染命令的命令面板子标题。它可以是预先存在的类别（例如，'notebook'），也可以是您自己选择的新的类别。

args 是一个 JSON 对象，它将在渲染/执行时传递到您的命令函数中。您可以使用这些参数根据命令的调用方式自定义其行为。例如，您可以传递 args: { isPalette: true }。您的命令 label 函数可以检查它提供的 args 中的 isPalette，并在这种情况下返回不同的标签。这对于使单个命令足够灵活以在多个上下文中工作非常有用。

上下文菜单 #

JupyterLab 具有一个应用程序范围的上下文菜单，可作为 app.contextMenu 使用。当用户右键单击时，应用程序上下文菜单将显示，并填充与用户单击的内容最相关的菜单项。

上下文菜单系统根据 CSS 选择器确定要显示哪些项目。它会向上传播 DOM 树，并测试给定的 HTML 元素是否与给定命令提供的 CSS 选择器匹配。

可以通过两种方式在上下文菜单中添加项目

使用设置 - 这是首选方式，因为它们是用户可配置的。
使用 API - 这是用于高级情况，例如动态菜单或语义项目。

以下是一个示例，展示了如何使用设置将命令添加到应用程序上下文菜单。

{
  "jupyter.lab.menus": {
  "context": [
    {
      "command": "my-command",
      "selector": ".jp-Notebook",
      "rank": 500
    }
  ]
}

在这个例子中，当用户右键点击匹配 .jp-Notebook 的 DOM 元素（即笔记本）时，将显示具有 id 为 my-command 的命令。选择器可以是任何有效的 CSS 选择器，可以针对您自己的 UI 元素或现有元素。上下文菜单命令当前使用的 CSS 选择器列表在常用 CSS 选择器中给出。

项目必须遵循以下定义

      "context": {
        "title": "The application context menu.",
        "description": "List of context menu items.",
        "items": {
          "allOf": [
            {
              "$ref": "#/definitions/menuItem"
            },
            {
              "properties": {
                "selector": {
                  "description": "The CSS selector for the context menu item.",
                  "type": "string"
                }
              }
            }
          ]
        },
        "type": "array",
        "default": []
      }

其中 menuItem 定义为

{
  "menuItem": {
    "properties": {
      "args": {
        "description": "Command arguments",
        "type": "object"
      },
      "command": {
        "description": "Command id",
        "type": "string"
      },
      "disabled": {
        "description": "Whether the item is disabled or not",
        "type": "boolean",
        "default": false
      },
      "type": {
        "description": "Item type",
        "type": "string",
        "enum": [
          "command",
          "submenu",
          "separator"
        ],
        "default": "command"
      },
      "rank": {
        "description": "Item rank",
        "type": "number",
        "minimum": 0
      },
      "submenu": {
        "oneOf": [
          {
            "$ref": "#/definitions/menu"
          },
          {
            "type": "null"
          }
        ]
      }
    },
    "type": "object"
  }
}

下面显示了使用 API 的相同示例。有关项目创建选项，请参阅 Lumino 文档。

app.contextMenu.addItem({
  command: commandID,
  selector: '.jp-Notebook'
})

如果您不想让 JupyterLab 的自定义上下文菜单出现在您的元素上，因为您有自己的右键单击行为要触发，您可以将 data-jp-suppress-context-menu 数据属性添加到任何节点，以使其及其子节点不触发它。

例如，如果您正在构建一个自定义 React 元素，它将看起来像这样

function MyElement(props: {}) {
  return (
    <div data-jp-suppress-context-menu>
      <p>Hi</p>
      <p onContextMenu={() => {console.log("right clicked")}}>There</p>
    </div>
  )
}

或者，您可以使用“contextmenu”事件监听器并调用 event.stopPropagation 来阻止应用程序上下文菜单处理程序被调用（它在 document 上的冒泡阶段监听）。此时，您可以显示您自己的 Lumino contextMenu，或者简单地停止传播并让系统上下文菜单显示。这在 Widget 子类中看起来像这样

// In `onAfterAttach()`
this.node.addEventListener('contextmenu', this);

// In `handleEvent()`
case 'contextmenu':
  event.stopPropagation();

复制可共享链接 #

文件浏览器提供了一个上下文菜单项“复制可共享链接”。所需的行为将因部署和它所服务的用户而异。文件浏览器支持覆盖此项目的行为。

import {
  IFileBrowserFactory
} from '@jupyterlab/filebrowser';

import {
  JupyterFrontEnd, JupyterFrontEndPlugin
} from '@jupyterlab/application';


const shareFile: JupyterFrontEndPlugin<void> = {
  activate: activateShareFile,
  id: commandID,
  requires: [IFileBrowserFactory],
  autoStart: true
};

function activateShareFile(
  app: JupyterFrontEnd,
  factory: IFileBrowserFactory
): void {
  const { commands } = app;
  const { tracker } = factory;

  commands.addCommand('filebrowser:share-main', {
    execute: () => {
      const widget = tracker.currentWidget;
      if (!widget) {
        return;
      }
      const path = encodeURI(widget.selectedItems().next().path);
      // Do something with path.
    },
    isVisible: () =>
      tracker.currentWidget &&
      Array.from(tracker.currentWidget.selectedItems()).length === 1,
    iconClass: 'jp-MaterialIcon jp-LinkIcon',
    label: 'Copy Shareable Link'
  });
}

请注意，提供此类替换插件的扩展必须自动禁用被替换的核心插件，或者用户必须手动禁用核心插件

jupyter labextension disable @jupyterlab/filebrowser-extension:share-file

键盘快捷键 #

在 JupyterLab 中添加键盘快捷键有两种方法。如果您不想让快捷键可供用户配置，您可以将它们直接添加到应用程序命令注册表中

app.commands.addKeyBinding({
  command: commandID,
  args: {},
  keys: ['Accel T'],
  selector: '.jp-Notebook'
});

在这个例子中，my-command 命令映射到 Accel T，其中 Accel 在 Mac 上对应于 Cmd，在 Windows 和 Linux 计算机上对应于 Ctrl。

键盘快捷键的行为与上下文菜单非常相似：快捷键处理程序从聚焦元素向上传播到 DOM 树，并针对注册的选择器测试每个元素。如果找到匹配项，则使用提供的 args 执行该命令。有关 addKeyBinding 选项的完整文档，请参见此处。

JupyterLab 还提供了与它的设置系统集成以用于键盘快捷键。您的扩展可以提供一个具有 jupyter.lab.shortcuts 键的设置模式，声明命令的默认键盘快捷键

{
  "jupyter.lab.shortcuts": [
    {
      "command": "my-command",
      "keys": ["Accel T"],
      "selector": ".jp-mod-searchable"
    }
  ]
}

添加到设置系统的快捷键将可供用户编辑。

从 Jupyterlab 版本 3.1 开始，可以使用单个快捷键执行多个命令。这需要您为 apputils:run-all-enabled 命令定义一个键盘快捷键

{
  "command": "apputils:run-all-enabled",
  "keys": ["Accel T"],
  "args": {
      "commands": [
          "my-command-1",
          "my-command-2"
      ],
      "args": [
          {},
          {}
        ]
    },
  "selector": "body"
}

在这个例子中，my-command-1 和 my-command-2 在 apputils:run-all-enabled 命令的 args 中作为 commands 列表传递。您也可以选择将 my-command-1 和 my-command-2 的命令参数在 apputils:run-all-enabled 命令的 args 中作为 args 列表传递。

启动器 #

与菜单、键盘快捷键和命令面板一样，可以通过命令将新项目添加到应用程序启动器。你可以通过在扩展中请求 ILauncher 令牌来实现这一点。

launcher.add({
  command: commandID,
  category: 'Other',
  rank: 0
});

除了提供命令 ID 外，你还需要提供一个类别来放置你的项目（例如“笔记本”或“其他”），以及一个等级来确定它在其他项目中的位置。

Jupyter 前端 Shell #

Jupyter 前端 shell 用于在应用程序中添加和交互内容。 IShell 接口提供了一个 add() 方法，用于将小部件添加到应用程序。在 JupyterLab 中，应用程序 shell 包含以下部分：

一个 top 区域，用于放置顶级工具栏和信息。
一个 menu 区域，用于放置顶级菜单，在多文档模式下会折叠到 top 区域，在单文档模式下则放置在它下方。
left 和 right 侧边栏区域，用于放置可折叠内容。
一个 main 工作区域，用于用户活动。
一个 down 区域，用于放置信息内容，例如日志控制台、上下文帮助。
一个 bottom 区域，用于放置状态栏等内容。
一个 header 区域，用于放置自定义元素。

顶部区域#

顶部区域旨在容纳大多数跨越用户整个会话的持久用户界面元素。主菜单栏右侧提供了一个名为 **TopBar** 的工具栏。例如，JupyterLab 在 collaborative 模式下启动时，会在该工具栏中添加一个用户下拉菜单。

请参阅通用工具栏，了解如何将工具栏或自定义小部件添加到工具栏。

你可以使用数字等级来控制设置中顶部栏项目的排序；请参阅工具栏定义。

默认情况下，JupyterLab 会在等级 50 的顶部栏中添加一个间隔符小部件。然后，你可以使用以下指南来放置你的项目：

rank <= 50 用于将项目放置在顶部栏的左侧
rank > 50 用于将项目放置在顶部栏的右侧

左侧/右侧区域#

JupyterLab 的左侧和右侧侧边栏区域旨在容纳比主区域更持久的用户界面元素。也就是说，扩展作者可以自由地将他们喜欢的任何组件添加到这些区域。你添加的对象的最外层级别应为 Lumino Widget，但它可以容纳你喜欢的任何内容（例如 React 组件）。

例如，以下代码将应用程序命令执行到终端小部件，然后将终端添加到右侧区域

app.commands
  .execute('terminal:create-new')
  .then((terminal: WidgetModuleType.Terminal) => {
    app.shell.add(terminal, 'right');
  });

你可以使用数字等级来控制左侧和右侧选项卡的排序

app.shell.add(terminal, 'left', {rank: 600});

此等级的推荐范围为：

0-500：保留给 JupyterLab 一方扩展。
501-899：保留给第三方扩展。
900：如果未指定等级，则为默认等级。
1000：JupyterLab 扩展管理器。

主菜单 #

有两种方法可以扩展 JupyterLab 的主菜单。

使用设置 - 这是首选方式，因为它们是用户可配置的。
使用 API - 这是用于高级情况，例如动态菜单或语义项目。

设置定义的菜单#

JupyterLab 提供了与设置系统集成的菜单定义。你的扩展可以提供一个具有 jupyter.lab.menus 键的设置模式，声明默认菜单。你无需在 TypeScript 代码中设置任何内容（除了命令定义）。

要使用你的扩展命令添加新菜单，请执行以下操作：

{
  "jupyter.lab.menus": {
  "main": [
    {
      "id": "jp-mainmenu-myextension",
      "label": "My Menu",
      "items": [
        {
          "command": "my-command",
          "rank": 500
        }
      ],
      "rank": 100
    }
  ]
}

菜单项标签将使用命令标签设置。对于菜单（和子菜单），需要使用 label 属性显式设置标签。

菜单和项都有一个 rank，它将决定元素的顺序。

要在现有菜单中添加新条目

{
  "jupyter.lab.menus": {
  "main": [
    {
      "id": "jp-mainmenu-file",
      "items": [
        {
          "command": "my-command",
          "rank": 500
        }
      ]
    }
  ]
}

以下是默认菜单 ID 的列表

文件菜单：jp-mainmenu-file
- 新建文件子菜单：jp-mainmenu-file-new
编辑菜单：jp-mainmenu-edit
视图菜单：jp-mainmenu-view
- 外观子菜单：jp-mainmenu-view-appearance
运行菜单：jp-mainmenu-run
内核菜单：jp-mainmenu-kernel
标签菜单：jp-mainmenu-tabs
设置菜单：jp-mainmenu-settings
帮助菜单：jp-mainmenu-help

默认主菜单在 mainmenu-extension 包设置中定义。

菜单必须遵守以下模式

      "main": {
        "title": "Main menu entries",
        "description": "List of menu items to add to the main menubar.",
        "items": {
          "$ref": "#/definitions/menu"
        },
        "type": "array",
        "default": []
      },

项必须遵循

{
  "menu": {
    "properties": {
      "disabled": {
        "description": "Whether the menu is disabled or not",
        "type": "boolean",
        "default": false
      },
      "icon": {
        "description": "Menu icon id",
        "type": "string"
      },
      "id": {
        "description": "Menu unique id",
        "oneOf": [
          {
            "type": "string",
            "enum": [
              "jp-menu-file",
              "jp-menu-file-new",
              "jp-menu-edit",
              "jp-menu-help",
              "jp-menu-kernel",
              "jp-menu-run",
              "jp-menu-settings",
              "jp-menu-view",
              "jp-menu-tabs"
            ]
          },
          {
            "type": "string",
            "pattern": "[a-z][a-z0-9\\-_]+"
          }
        ]
      },
      "items": {
        "description": "Menu items",
        "type": "array",
        "items": {
          "$ref": "#/definitions/menuItem"
        }
      },
      "label": {
        "description": "Menu label",
        "type": "string"
      },
      "mnemonic": {
        "description": "Mnemonic index for the label",
        "type": "number",
        "minimum": -1,
        "default": -1
      },
      "rank": {
        "description": "Menu rank",
        "type": "number",
        "minimum": 0
      }
    },
    "required": [
      "id"
    ],
    "type": "object"
  }
}

添加到设置系统中的菜单可以通过用户使用 mainmenu-extension 设置进行编辑。特别是，可以通过将属性 disabled 设置为 true 来在项或菜单级别禁用它们。

API 定义的菜单#

要使用 API，您应该为您的扩展请求 IMainMenu 令牌。

扩展主要有三种方式

您可以将自己的菜单添加到菜单栏。
您可以将新命令添加到现有菜单。
您可以将您的扩展注册到现有的语义菜单项之一。

将新命令添加到现有菜单#

在许多情况下，您希望将命令添加到现有的 JupyterLab 菜单中，而不是为您的扩展创建单独的菜单。由于顶级 JupyterLab 菜单在许多扩展之间共享，因此添加项的 API 略有不同。在这种情况下，您提供一个命令列表和一个等级，这些命令将一起显示在现有菜单中的一个单独组中。

例如，要将包含 firstCommandID 和 secondCommandID 的命令组添加到文件菜单，您将执行以下操作

mainMenu.fileMenu.addGroup([
  {
    command: firstCommandID,
  },
  {
    command: secondCommandID,
  }
], 40 /* rank */);

注册语义菜单项#

JupyterLab 菜单系统中有一些命令被认为是通用且重要的，因此它们的处理方式不同。

例如，我们预计许多活动可能希望提供一个命令来关闭自身并执行一些清理操作（例如关闭控制台并关闭其内核）。为了避免这种常见的“关闭和清理”操作出现大量类似的菜单项，我们提供了一个可以适应此用例的单个命令，我们称之为“语义菜单项”。对于此示例，它是文件菜单 closeAndCleaners 集。

以下是如何使用 closeAndCleaners 语义菜单项的示例

mainMenu.fileMenu.closeAndCleaners.add({
  id: 'notebook:close-and-shutdown',
  isEnabled: (w: Widget) => tracker.currentWidget !== null && tracker.has(w)
});

在此示例中，tracker 是一个 Widget Tracker，它允许菜单项确定是否将菜单命令委托给您的活动，而 id 是命令标识符。

在 JupyterLab 代码库中可以找到更多关于如何注册语义菜单项的示例。可用的语义菜单项有

IEditMenu.IUndoer: 一个知道如何撤销和重做的活动。
IEditMenu.IClearer: 一个知道如何清除其内容的活动。
IEditMenu.IGoToLiner: 一个知道如何跳转到指定行的活动。
IFileMenu.ICloseAndCleaner: 一个知道如何关闭并清理自身后的活动。
IFileMenu.IConsoleCreator: 一个知道如何为自身创建一个附加代码控制台的活动。
IHelpMenu.IKernelUser: 一个知道如何获取相关内核会话的活动。
IKernelMenu.IKernelUser: 一个可以执行各种内核相关操作的活动。
IRunMenu.ICodeRunner: 一个可以从其内容中运行代码的活动。
IViewMenu.IEditorViewer: 一个知道如何设置其拥有的文本编辑器上的各种视图相关选项的活动。

状态栏 #

JupyterLab 的状态栏旨在显示少量上下文信息。与左右区域一样，它只期望一个 Lumino Widget，它可能包含任何类型的内容。由于状态栏的空间有限，您应该努力只向其中添加小型部件。

以下示例展示了如何放置一个状态项，该项显示应用程序当前的“繁忙”状态。此信息可从 ILabStatus 令牌中获取，我们通过名为 labStatus 的变量引用它。我们将 statusWidget 放置在状态栏的中间。当 labStatus 繁忙状态发生变化时，我们将更新 statusWidget 的文本内容以反映这一点。

const statusWidget = new Widget();
labStatus.busySignal.connect(() => {
  statusWidget.node.textContent = labStatus.isBusy ? 'Busy' : 'Idle';
});
statusBar.registerStatusItem('lab-status', {
  align: 'middle',
  item: statusWidget
});

工具栏注册表 #

JupyterLab 提供了一个基础设施，用于从设置中定义和自定义工具栏小部件，这与定义上下文菜单和主菜单栏类似。

文档小部件#

一个典型的例子是笔记本工具栏，如以下代码片段所示

function activatePlugin(
  app: JupyterFrontEnd,
  // ...
  toolbarRegistry: IToolbarWidgetRegistry | null,
  settingRegistry: ISettingRegistry | null
): NotebookWidgetFactory.IFactory {
  const { commands } = app;
  let toolbarFactory:
    | ((widget: NotebookPanel) => DocumentRegistry.IToolbarItem[])
    | undefined;

  // Register notebook toolbar specific widgets
  if (toolbarRegistry) {
    toolbarRegistry.registerFactory<NotebookPanel>(FACTORY, 'cellType', panel =>
      ToolbarItems.createCellTypeItem(panel, translator)
    );

    toolbarRegistry.registerFactory<NotebookPanel>(
      FACTORY,
      'kernelStatus',
      panel => Toolbar.createKernelStatusItem(panel.sessionContext, translator)
    );
    // etc...

    if (settingRegistry) {
      // Create the factory
      toolbarFactory = createToolbarFactory(
        toolbarRegistry,
        settingRegistry,
        // Factory name
        FACTORY,
        // Setting id in which the toolbar items are defined
        '@jupyterlab/notebook-extension:panel',
        translator
      );
    }
  }

  const factory = new NotebookWidgetFactory({
    name: FACTORY,
    fileTypes: ['notebook'],
    modelName: 'notebook',
    defaultFor: ['notebook'],
    // ...
    toolbarFactory,
    translator: translator
  });
  app.docRegistry.addWidgetFactory(factory);

注册表 registerFactory 方法允许扩展为唯一的对（工厂名称，工具栏项名称）提供特殊的小部件。然后，辅助函数 createToolbarFactory 可用于从设置中提取工具栏定义并构建工厂以传递给小部件工厂。

默认工具栏项可以通过在 "jupyter.lab.toolbars" 映射中提供条目来在多个扩展中定义。例如，对于笔记本面板

设置注册表将透明地将这些定义从设置模式与任何用户提供的覆盖（自定义）合并，并将它们保存在最终设置对象中的 toolbar 属性下。 toolbar 列表将用于创建工具栏。源设置模式和最终设置对象都由传递给 createToolbarFactory 的插件 ID 标识。用户可以通过添加新项或覆盖现有项来自定义工具栏（例如，提供不同的等级或添加 "disabled": true 来删除该项）。

注意

您需要在将收集所有项目的插件 ID 中将 jupyter.lab.transform 设置为 true。

当前支持工具栏自定义的小部件工厂有

Notebook: 笔记本面板工具栏
Cell: 单元格工具栏
Editor: 文本编辑器工具栏
HTML Viewer: HTML 查看器工具栏
CSVTable: CSV（逗号分隔值）查看器工具栏
TSVTable: TSV（制表符分隔值）查看器工具栏

{
  "toolbarItem": {
    "properties": {
      "name": {
        "title": "Unique name",
        "type": "string"
      },
      "args": {
        "title": "Command arguments",
        "type": "object"
      },
      "command": {
        "title": "Command id",
        "type": "string",
        "default": ""
      },
      "disabled": {
        "title": "Whether the item is ignored or not",
        "type": "boolean",
        "default": false
      },
      "icon": {
        "title": "Item icon id",
        "description": "If defined, it will override the command icon",
        "type": "string"
      },
      "label": {
        "title": "Item label",
        "description": "If defined, it will override the command label",
        "type": "string"
      },
      "caption": {
        "title": "Item caption",
        "description": "If defined, it will override the command caption",
        "type": "string"
      },
      "type": {
        "title": "Item type",
        "type": "string",
        "enum": [
          "command",
          "spacer"
        ]
      },
      "rank": {
        "title": "Item rank",
        "type": "number",
        "minimum": 0,
        "default": 50
      }
    },
    "required": [
      "name"
    ],
    "additionalProperties": false,
    "type": "object"
  }
}

小部件跟踪器 #

扩展程序通常希望与其他扩展程序创建的文档和活动进行交互。例如，扩展程序可能希望将一些文本注入笔记本单元格，或设置自定义键映射，或关闭所有特定类型的文档。这些操作通常由小部件跟踪器完成。扩展程序在 WidgetTrackers 中跟踪其活动的实例，这些实例随后作为令牌提供，以便其他扩展程序可以请求它们。

例如，如果您想与笔记本进行交互，您应该请求 INotebookTracker 令牌。然后，您可以使用此跟踪器来迭代、过滤和搜索所有打开的笔记本。您还可以使用它在笔记本添加到跟踪器或从跟踪器中删除时通过信号接收通知。

许多 JupyterLab 活动都提供了小部件跟踪器令牌，包括笔记本、控制台、文本文件、MIME 文档和终端。如果您在 JupyterLab 中添加了自己的活动，您可能需要考虑提供自己的 WidgetTracker 令牌，以便其他扩展程序可以使用它。

完成提供程序 #

代码完成器和内联完成器都可以通过在 ICompletionProviderManager 令牌提供的完成管理器上注册（内联）完成提供程序来扩展。

代码完成器#

最小的代码完成提供程序需要实现 fetch 和 isApplicable 方法，并定义一个唯一的 identifier 属性，但 ICompletionProvider 接口允许对完成器进行更广泛的自定义。

import {
  CompletionHandler,
  ICompletionProviderManager,
  ICompletionContext,
  ICompletionProvider
} from '@jupyterlab/completer';

class MyProvider implements ICompletionProvider {
  readonly identifier = 'my-provider';

  async isApplicable(context: ICompletionContext) {
    return true;
  }

  async fetch(
    request: CompletionHandler.IRequest,
    context: ICompletionContext
  ) {
    return {
      start: request.offset,
      end: request.offset,
      items: [
        { label: 'option 1' },
        { label: 'option 2' }
      ]
    };
  }
}

const plugin: JupyterFrontEndPlugin<void> = {
  id: 'my-completer-extension:provider',
  autoStart: true,
  requires: [ICompletionProviderManager],
  activate: (app: JupyterFrontEnd, manager: ICompletionProviderManager): void => {
    const provider = new MyProvider();
    manager.registerProvider(provider);
  }
};

在 extension-examples 存储库中提供了更详细的示例。

有关广泛定制的完成提供程序的示例，请参阅 jupyterlab-lsp 扩展。

内联完成器#

最小的内联完成提供程序扩展将只实现所需方法 fetch 并定义 identifier 和 name 属性，但可以使用许多其他字段来增强功能，例如流，请参阅 IInlineCompletionProvider 文档。

import {
  CompletionHandler,
  ICompletionProviderManager,
  IInlineCompletionContext,
  IInlineCompletionProvider
} from '@jupyterlab/completer';

class MyInlineProvider implements IInlineCompletionProvider {
  readonly identifier = 'my-provider';
  readonly name = 'My provider';

  async fetch(
    request: CompletionHandler.IRequest,
    context: IInlineCompletionContext
  ) {
    return {
      items: [
        { insertText: 'suggestion 1' },
        { insertText: 'suggestion 2' }
      ]
    };
  }
}

const plugin: JupyterFrontEndPlugin<void> = {
  id: 'my-completer-extension:inline-provider',
  autoStart: true,
  requires: [ICompletionProviderManager],
  activate: (app: JupyterFrontEnd, manager: ICompletionProviderManager): void => {
    const provider = new MyInlineProvider();
    manager.registerInlineProvider(provider);
  }
};

有关具有流支持的内联完成提供程序的示例，请参阅 jupyterlab-transformers-completer。

状态数据库 #

可以通过从 @jupyterlab/statedb 导入 IStateDB 并将其添加到插件的 requires 列表中来访问状态数据库

const id = 'foo-extension:IFoo';

const IFoo = new Token<IFoo>(id);

interface IFoo {}

class Foo implements IFoo {}

const plugin: JupyterFrontEndPlugin<IFoo> = {
  id,
  autoStart: true,
  requires: [IStateDB],
  provides: IFoo,
  activate: (app: JupyterFrontEnd, state: IStateDB): IFoo => {
    const foo = new Foo();
    const key = `${id}:some-attribute`;

    // Load the saved plugin state and apply it once the app
    // has finished restoring its former layout.
    Promise.all([state.fetch(key), app.restored])
      .then(([saved]) => { /* Update `foo` with `saved`. */ });

    // Fulfill the plugin contract by returning an `IFoo`.
    return foo;
  }
};

LSP 功能 #

JupyterLab 提供了一个与语言服务器通信的基础设施。如果 LSP 服务已激活并且用户已安装语言服务器，JupyterLab 将为打开的笔记本或文件的语言启动语言服务器。扩展作者可以通过从 @jupyterlab/lsp 中请求 ILSPDocumentConnectionManager 令牌来访问打开文档的虚拟文档和关联的 LSP 连接。

以下是一个向语言服务器发出请求的示例。

const plugin: JupyterFrontEndPlugin<void> = {
  id,
  autoStart: true,
  requires: [ILSPDocumentConnectionManager],
  activate: async (app: JupyterFrontEnd, manager: ILSPDocumentConnectionManager): Promise<void> => {

    // Get the path to the opened notebook of file
    const path = ...

    // Get the widget adapter of opened document
    const adapter = manager.adapters.get(path);
    if (!adapter) {
      return
    }
    // Get the associated virtual document of the opened document
    const virtualDocument = adapter.virtualDocument;

    // Get the LSP connection of the virtual document.
    const connection = manager.connections.get(virtualDocument.uri);
    ...
    // Send completion request to the language server
    const response = await connection.clientRequests['textDocument/completion'].request(params);
    ...
  }
};

有时，LSP 扩展会包含一个 CodeMirror 扩展来修改代码编辑器。在这种情况下，您可以参考以下示例。

const renamePlugin: JupyterFrontEndPlugin<void> = {
  id,
  autoStart: true,
  requires: [ILSPDocumentConnectionManager, ILSPFeatureManager, IWidgetLSPAdapterTracker],
  activate: (app: JupyterFrontEnd, connectionManager: ILSPDocumentConnectionManager, featureManager: ILSPFeatureManager, tracker: IWidgetLSPAdapterTracker) => {
    const FEATURE_ID = "rename_symbol";
    const extensionFactory: EditorAdapter.ILSPEditorExtensionFactory = {
      name: FEATURE_ID,
      factory: (options) =>  {
        const { editor, widgetAdapter } = options;

        // Get the editor
        const ceEditor: CodeEditor.IEditor | null = editor.getEditor();
        if (!ceEditor) {
          return null;
        }

        // Get the associated virtual document of the opened document
        if (!widgetAdapter.virtualDocument) {
          return null;
        }

        // Get the LSP connection of the virtual document.
        const connection = connectionManager.connections.get(widgetAdapter.virtualDocument.uri);
        if (!connection || !connection.provides('renameProvider')) {
          return null;
        }

        // Create a CodeMirror extension that listens for double click, gets the
        // selected code and makes a LSP request to rename it and prints the results.
        const ext = EditorView.domEventHandlers({ dblclick: (e, view) => {
          const range = ceEditor.getSelection();
            const res = connection.clientRequests['textDocument/rename'].request({
              newName: "test",
              position: { line: range.start.line, character: range.start.column },
              textDocument: { uri: widgetAdapter.virtualDocument!.uri }
            });

            res.then(value => {
              console.debug(value);
            }).catch(e => console.error);
        }});

        // Wrap the CodeMirror extension in the extension registry object.
        return EditorExtensionRegistry.createImmutableExtension(ext);
      }
    }

    // Register the extension with the LSP feature
    featureManager.register({
      id: FEATURE_ID,
      extensionFactory
    });
  }
};

常用扩展点#

核心插件 #

核心令牌 #

命令 #

将命令添加到命令注册表#

将命令添加到命令面板#

上下文菜单 #

复制可共享链接 #

图标 #

键盘快捷键 #

启动器 #

Jupyter 前端 Shell #

顶部区域#

左侧/右侧区域#

主菜单 #

设置定义的菜单#

API 定义的菜单#

添加新菜单#

将新命令添加到现有菜单#

注册语义菜单项#

状态栏 #

小部件跟踪器 #

完成提供程序 #

代码完成器#

内联完成器#

状态数据库 #

LSP 功能 #

常用扩展点#

将命令添加到命令注册表#

将命令添加到命令面板#

顶部区域#

左侧/右侧区域#

设置定义的菜单#

API 定义的菜单#

添加新菜单#

将新命令添加到现有菜单#

注册语义菜单项#

文档小部件#

带工具栏的通用小部件#

代码完成器#

内联完成器#