@codingame/monaco-vscode-notebook-service-override 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.js

@@ -27,7 +27,6 @@ import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
-import { NotebookCellOutlineProvider } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProvider';
 import { CellKind, NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -44,8 +43,10 @@ import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
 import { IOutlinePane } from 'vscode/vscode/vs/workbench/contrib/outline/browser/outline';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { NOTEBOOK_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { INotebookCellOutlineProviderFactory } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProviderFactory.service';
 
 var NotebookCellOutline_1;
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline";
 class NotebookOutlineTemplate {
     static { this.templateId = 'NotebookOutlineRenderer'; }
     constructor(container, iconClass, iconLabel, decoration, actionMenu, elementDisposables) {
@@ -70,25 +71,27 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
         this.templateId = NotebookOutlineTemplate.templateId;
     }
     renderTemplate(container) {
-        const elementDisposables = ( new DisposableStore());
+        const elementDisposables = ( (new DisposableStore()));
         container.classList.add('notebook-outline-element', 'show-file-icons');
         const iconClass = document.createElement('div');
         container.append(iconClass);
-        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
+        const iconLabel = ( (new IconLabel(container, { supportHighlights: true })));
         const decoration = document.createElement('div');
         decoration.className = 'element-decoration';
         container.append(decoration);
         const actionMenu = document.createElement('div');
         actionMenu.className = 'action-menu';
         container.append(actionMenu);
-        return ( new NotebookOutlineTemplate(
-            container,
-            iconClass,
-            iconLabel,
-            decoration,
-            actionMenu,
-            elementDisposables
-        ));
+        return (
+             (new NotebookOutlineTemplate(
+                container,
+                iconClass,
+                iconLabel,
+                decoration,
+                actionMenu,
+                elementDisposables
+            ))
+        );
     }
     renderElement(node, _index, template, _height) {
         const extraClasses = [];
@@ -151,17 +154,17 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
             const scopedContextKeyService = template.elementDisposables.add(this._contextKeyService.createScoped(template.container));
             NotebookOutlineContext.CellKind.bindTo(scopedContextKeyService).set(isCodeCell ? CellKind.Code : CellKind.Markup);
             NotebookOutlineContext.CellHasChildren.bindTo(scopedContextKeyService).set(length > 0);
-            NotebookOutlineContext.CellHasHeader.bindTo(scopedContextKeyService).set(node.element.level !== 7);
+            NotebookOutlineContext.CellHasHeader.bindTo(scopedContextKeyService).set(node.element.level !== 7 );
             NotebookOutlineContext.OutlineElementTarget.bindTo(scopedContextKeyService).set(this._target);
             this.setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell);
-            const outlineEntryToolbar = template.elementDisposables.add(( new ToolBar(template.actionMenu, this._contextMenuService, {
+            const outlineEntryToolbar = template.elementDisposables.add(( (new ToolBar(template.actionMenu, this._contextMenuService, {
                 actionViewItemProvider: action => {
                     if (action instanceof MenuItemAction) {
                         return this._instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
                     }
                     return undefined;
                 },
-            })));
+            }))));
             const menu = template.elementDisposables.add(this._menuService.createMenu(MenuId.NotebookOutlineActionMenu, scopedContextKeyService));
             const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: node.element });
             outlineEntryToolbar.setActions(actions.primary, actions.secondary);
@@ -220,14 +223,14 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
         }));
     }
 };
-NotebookOutlineRenderer = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IInstantiationService))
-], NotebookOutlineRenderer));
+NotebookOutlineRenderer = ( (__decorate([
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IContextKeyService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IInstantiationService)))
+], NotebookOutlineRenderer)));
 function getOutlineToolbarActions(menu, args) {
     const primary = [];
     const secondary = [];
@@ -257,8 +260,9 @@ class NotebookOutlineVirtualDelegate {
     }
 }
 let NotebookQuickPickProvider = class NotebookQuickPickProvider {
-    constructor(_getEntries, _themeService) {
+    constructor(_getEntries, _configurationService, _themeService) {
         this._getEntries = _getEntries;
+        this._configurationService = _configurationService;
         this._themeService = _themeService;
     }
     getQuickPickElements() {
@@ -268,7 +272,21 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         }
         const result = [];
         const { hasFileIcons } = this._themeService.getFileIconTheme();
-        for (const element of bucket) {
+        const showSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+        const isSymbol = (element) => !!element.symbolKind;
+        const isCodeCell = (element) => ((element.cell.cellKind === CellKind.Code && element.level === 7) );
+        for (let i = 0; i < bucket.length; i++) {
+            const element = bucket[i];
+            const nextElement = bucket[i + 1];
+            if (!showSymbols
+                && isSymbol(element)) {
+                continue;
+            }
+            if (showSymbols
+                && isCodeCell(element)
+                && nextElement && isSymbol(nextElement)) {
+                continue;
+            }
             const useFileIcon = hasFileIcons && !element.symbolKind;
             result.push({
                 element,
@@ -280,9 +298,10 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         return result;
     }
 };
-NotebookQuickPickProvider = ( __decorate([
-    ( __param(1, IThemeService))
-], NotebookQuickPickProvider));
+NotebookQuickPickProvider = ( (__decorate([
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IThemeService)))
+], NotebookQuickPickProvider)));
 class NotebookComparator {
     constructor() {
         this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
@@ -299,32 +318,32 @@ class NotebookComparator {
 }
 let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
     get entries() {
-        return this._outlineProvider?.entries ?? [];
+        return this._outlineProviderReference?.object?.entries ?? [];
     }
     get activeElement() {
-        return this._outlineProvider?.activeElement;
+        return this._outlineProviderReference?.object?.activeElement;
     }
     constructor(_editor, _target, instantiationService, _editorService, _configurationService) {
         this._editor = _editor;
         this._editorService = _editorService;
-        this._dispoables = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
+        this._dispoables = ( (new DisposableStore()));
+        this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this._entriesDisposables = ( new DisposableStore());
+        this._entriesDisposables = ( (new DisposableStore()));
         this.outlineKind = 'notebookCells';
-        this._localDisposables = ( new DisposableStore());
+        this._localDisposables = ( (new DisposableStore()));
         const installSelectionListener = () => {
             const notebookEditor = _editor.getControl();
             if (!notebookEditor?.hasModel()) {
-                this._outlineProvider?.dispose();
-                this._outlineProvider = undefined;
+                this._outlineProviderReference?.dispose();
+                this._outlineProviderReference = undefined;
                 this._localDisposables.clear();
             }
             else {
-                this._outlineProvider?.dispose();
+                this._outlineProviderReference?.dispose();
                 this._localDisposables.clear();
-                this._outlineProvider = instantiationService.createInstance(NotebookCellOutlineProvider, notebookEditor, _target);
-                this._localDisposables.add(this._outlineProvider.onDidChange(e => {
+                this._outlineProviderReference = instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineProviderFactory).getOrCreate(notebookEditor, _target));
+                this._localDisposables.add(this._outlineProviderReference.object.onDidChange(e => {
                     this._onDidChange.fire(e);
                 }));
             }
@@ -338,16 +357,16 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
                 return this.getChildren(parent, _configurationService);
             }
         };
-        const delegate = ( new NotebookOutlineVirtualDelegate());
+        const delegate = ( (new NotebookOutlineVirtualDelegate()));
         const renderers = [instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), _target)];
-        const comparator = ( new NotebookComparator());
+        const comparator = ( (new NotebookComparator()));
         const options = {
             collapseByDefault: _target === 2  || ((_target === 1  && _configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
             expandOnlyOnTwistieClick: true,
             multipleSelectionSupport: false,
-            accessibilityProvider: ( new NotebookOutlineAccessibility()),
-            identityProvider: { getId: element => ( element.cell.uri.toString()) },
-            keyboardNavigationLabelProvider: ( new NotebookNavigationLabelProvider())
+            accessibilityProvider: ( (new NotebookOutlineAccessibility())),
+            identityProvider: { getId: element => ( (element.cell.uri.toString())) },
+            keyboardNavigationLabelProvider: ( (new NotebookNavigationLabelProvider()))
         };
         this.config = {
             breadcrumbsDataSource: {
@@ -361,7 +380,7 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
                     return result;
                 }
             },
-            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this._outlineProvider?.entries ?? [])),
+            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this._outlineProviderReference?.object?.entries ?? [])),
             treeDataSource,
             delegate,
             renderers,
@@ -373,12 +392,12 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
         const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
         const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
         const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
-        for (const entry of parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children) {
+        for (const entry of parent instanceof NotebookCellOutline_1 ? (this._outlineProviderReference?.object?.entries ?? []) : parent.children) {
             if (entry.cell.cellKind === CellKind.Markup) {
                 if (!showMarkdownHeadersOnly) {
                     yield entry;
                 }
-                else if (entry.level < 7) {
+                else if (entry.level < 7 ) {
                     yield entry;
                 }
             }
@@ -386,20 +405,20 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
                 if (showCodeCellSymbols) {
                     yield entry;
                 }
-                else if (entry.level === 7) {
+                else if (entry.level === 7 ) {
                     yield entry;
                 }
             }
         }
     }
     async setFullSymbols(cancelToken) {
-        await this._outlineProvider?.setFullSymbols(cancelToken);
+        await this._outlineProviderReference?.object?.setFullSymbols(cancelToken);
     }
     get uri() {
-        return this._outlineProvider?.uri;
+        return this._outlineProviderReference?.object?.uri;
     }
     get isEmpty() {
-        return this._outlineProvider?.isEmpty ?? true;
+        return this._outlineProviderReference?.object?.isEmpty ?? true;
     }
     async reveal(entry, options, sideBySide) {
         await this._editorService.openEditor({
@@ -469,15 +488,15 @@ let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
         this._onDidChange.dispose();
         this._dispoables.dispose();
         this._entriesDisposables.dispose();
-        this._outlineProvider?.dispose();
+        this._outlineProviderReference?.dispose();
         this._localDisposables.dispose();
     }
 };
-NotebookCellOutline = NotebookCellOutline_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IConfigurationService))
-], NotebookCellOutline));
+NotebookCellOutline = NotebookCellOutline_1 = ( (__decorate([
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IEditorService))),
+    ( (__param(4, IConfigurationService)))
+], NotebookCellOutline)));
 let NotebookOutlineCreator = class NotebookOutlineCreator {
     constructor(outlineService, _instantiationService, _configurationService) {
         this._instantiationService = _instantiationService;
@@ -496,25 +515,25 @@ let NotebookOutlineCreator = class NotebookOutlineCreator {
             await outline.setFullSymbols(cancelToken);
         }
         else if (target === 1  && showAllOutlineSymbols) {
-            await outline.setFullSymbols(cancelToken);
+            void outline.setFullSymbols(cancelToken);
         }
         return outline;
     }
 };
-NotebookOutlineCreator = ( __decorate([
-    ( __param(0, IOutlineService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService))
-], NotebookOutlineCreator));
+NotebookOutlineCreator = ( (__decorate([
+    ( (__param(0, IOutlineService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IConfigurationService)))
+], NotebookOutlineCreator)));
 const NotebookOutlineContext = {
-    CellKind: ( new RawContextKey('notebookCellKind', undefined)),
-    CellHasChildren: ( new RawContextKey('notebookCellHasChildren', false)),
-    CellHasHeader: ( new RawContextKey('notebookCellHasHeader', false)),
-    CellFoldingState: ( new RawContextKey('notebookCellFoldingState', 0 )),
-    OutlineElementTarget: ( new RawContextKey('notebookOutlineElementTarget', undefined)),
+    CellKind: ( (new RawContextKey('notebookCellKind', undefined))),
+    CellHasChildren: ( (new RawContextKey('notebookCellHasChildren', false))),
+    CellHasHeader: ( (new RawContextKey('notebookCellHasHeader', false))),
+    CellFoldingState: ( (new RawContextKey('notebookCellFoldingState', 0 ))),
+    OutlineElementTarget: ( (new RawContextKey('notebookOutlineElementTarget', undefined))),
 };
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
+( (Registry.as(Extensions$1.Configuration))).registerConfiguration({
     id: 'notebook',
     order: 100,
     type: 'object',
@@ -523,44 +542,36 @@ const NotebookOutlineContext = {
             type: 'boolean',
             default: true,
             markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showMarkdownHeadersOnly',
+                _moduleId,
+                0,
                 "When enabled, notebook outline will show only markdown cells containing a header."
             ))
         },
         [NotebookSetting.outlineShowCodeCells]: {
             type: 'boolean',
             default: false,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showCodeCells',
-                "When enabled, notebook outline shows code cells."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 1, "When enabled, notebook outline shows code cells."))
         },
         [NotebookSetting.outlineShowCodeCellSymbols]: {
             type: 'boolean',
             default: true,
             markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showCodeCellSymbols',
+                _moduleId,
+                2,
                 "When enabled, notebook outline shows code cell symbols. Relies on `notebook.outline.showCodeCells` being enabled."
             ))
         },
         [NotebookSetting.breadcrumbsShowCodeCells]: {
             type: 'boolean',
             default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'breadcrumbs.showCodeCells',
-                "When enabled, notebook breadcrumbs contain code cells."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 3, "When enabled, notebook breadcrumbs contain code cells."))
         },
         [NotebookSetting.gotoSymbolsAllSymbols]: {
             type: 'boolean',
             default: true,
             markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'notebook.gotoSymbols.showAllSymbols',
+                _moduleId,
+                4,
                 "When enabled, the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
             ))
         },
@@ -568,28 +579,23 @@ const NotebookOutlineContext = {
 });
 MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
     submenu: MenuId.NotebookOutlineFilter,
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-        'filter',
-        "Filter Entries"
-    )),
+    title: ( localizeWithPath(_moduleId, 5, "Filter Entries")),
     icon: Codicon.filter,
     group: 'navigation',
     order: -1,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', IOutlinePane.Id)), NOTEBOOK_IS_ACTIVE_EDITOR)),
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.equals('view', IOutlinePane.Id)),
+        NOTEBOOK_IS_ACTIVE_EDITOR
+    ))),
 });
 registerAction2(class ToggleShowMarkdownHeadersOnly extends Action2 {
     constructor() {
         super({
             id: 'notebook.outline.toggleShowMarkdownHeadersOnly',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleShowMarkdownHeadersOnly',
-                "Markdown Headers Only"
-            )),
+            title: ( localizeWithPath(_moduleId, 6, "Markdown Headers Only")),
             f1: false,
             toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showMarkdownHeadersOnly', true))
+                condition: ( (ContextKeyExpr.equals('config.notebook.outline.showMarkdownHeadersOnly', true)))
             },
             menu: {
                 id: MenuId.NotebookOutlineFilter,
@@ -607,14 +613,10 @@ registerAction2(class ToggleCodeCellEntries extends Action2 {
     constructor() {
         super({
             id: 'notebook.outline.toggleCodeCells',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleCodeCells',
-                "Code Cells"
-            )),
+            title: ( localizeWithPath(_moduleId, 7, "Code Cells")),
             f1: false,
             toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCells', true))
+                condition: ( (ContextKeyExpr.equals('config.notebook.outline.showCodeCells', true)))
             },
             menu: {
                 id: MenuId.NotebookOutlineFilter,
@@ -633,14 +635,10 @@ registerAction2(class ToggleCodeCellSymbolEntries extends Action2 {
     constructor() {
         super({
             id: 'notebook.outline.toggleCodeCellSymbols',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleCodeCellSymbols',
-                "Code Cell Symbols"
-            )),
+            title: ( localizeWithPath(_moduleId, 8, "Code Cell Symbols")),
             f1: false,
             toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCellSymbols', true))
+                condition: ( (ContextKeyExpr.equals('config.notebook.outline.showCodeCellSymbols', true)))
             },
             menu: {
                 id: MenuId.NotebookOutlineFilter,

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile.js

@@ -3,12 +3,13 @@ import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/comm
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile";
 var NotebookProfileType;
-( (function(NotebookProfileType) {
+( ((function(NotebookProfileType) {
     NotebookProfileType["default"] = "default";
     NotebookProfileType["jupyter"] = "jupyter";
     NotebookProfileType["colab"] = "colab";
-})(NotebookProfileType || (NotebookProfileType = {})));
+})(NotebookProfileType || (NotebookProfileType = {}))));
 const profiles = {
     [NotebookProfileType.default]: {
         [NotebookSetting.focusIndicator]: 'gutter',
@@ -52,11 +53,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.setProfile',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile',
-                'setProfileTitle',
-                "Set Profile"
-            ))
+            title: ( localizeWithPath(_moduleId, 0, "Set Profile"))
         });
     }
     async run(accessor, args) {