@codingame/monaco-vscode-notebook-service-override 6.0.3 → 7.0.0

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

@@ -28,12 +28,13 @@ import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeServi
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { CellFoldingState, CellRevealType } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
-import { CellKind, NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { CellKind, NotebookSetting, NotebookCellsChangeType } 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';
 import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { OutlineConfigKeys, OutlineTarget, OutlineConfigCollapseItemsValues } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
 import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline.service';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
@@ -42,12 +43,15 @@ import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.s
 import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
+import { disposableTimeout, Delayer } 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 { NotebookOutlineConstants } from '../../viewModel/notebookOutlineEntryFactory.js';
-import { INotebookCellOutlineProviderFactory } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProviderFactory.service';
+import { INotebookCellOutlineDataSourceFactory } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.service';
+import { NotebookExecutionType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 
 const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline";
 class NotebookOutlineTemplate {
@@ -263,29 +267,35 @@ class NotebookOutlineVirtualDelegate {
     }
 }
 let NotebookQuickPickProvider = class NotebookQuickPickProvider {
-    constructor(_getEntries, _configurationService, _themeService) {
-        this._getEntries = _getEntries;
+    constructor(notebookCellOutlineDataSourceRef, _configurationService, _themeService) {
+        this.notebookCellOutlineDataSourceRef = notebookCellOutlineDataSourceRef;
         this._configurationService = _configurationService;
         this._themeService = _themeService;
+        this._disposables = ( (new DisposableStore()));
+        this.gotoShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.gotoSymbolsAllSymbols)) {
+                this.gotoShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+            }
+        }));
     }
     getQuickPickElements() {
         const bucket = [];
-        for (const entry of this._getEntries()) {
+        for (const entry of this.notebookCellOutlineDataSourceRef?.object?.entries ?? []) {
             entry.asFlatList(bucket);
         }
         const result = [];
         const { hasFileIcons } = this._themeService.getFileIconTheme();
-        const showSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
         const isSymbol = (element) => !!element.symbolKind;
         const isCodeCell = (element) => (element.cell.cellKind === CellKind.Code && element.level === NotebookOutlineConstants.NonHeaderOutlineLevel);
         for (let i = 0; i < bucket.length; i++) {
             const element = bucket[i];
             const nextElement = bucket[i + 1];
-            if (!showSymbols
+            if (!this.gotoShowCodeCellSymbols
                 && isSymbol(element)) {
                 continue;
             }
-            if (showSymbols
+            if (this.gotoShowCodeCellSymbols
                 && isCodeCell(element)
                 && nextElement && isSymbol(nextElement)) {
                 continue;
@@ -300,33 +310,76 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         }
         return result;
     }
+    dispose() {
+        this._disposables.dispose();
+    }
 };
 NotebookQuickPickProvider = ( (__decorate([
     ( (__param(1, IConfigurationService))),
     ( (__param(2, IThemeService)))
 ], NotebookQuickPickProvider)));
 let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
-    constructor(_getEntries, _configurationService) {
-        this._getEntries = _getEntries;
+    constructor(outlineDataSourceRef, _configurationService) {
+        this.outlineDataSourceRef = outlineDataSourceRef;
         this._configurationService = _configurationService;
+        this._disposables = ( (new DisposableStore()));
+        this.showCodeCells = this._configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+        this.showCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        this.showMarkdownHeadersOnly = this._configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.outlineShowCodeCells)) {
+                this.showCodeCells = this._configurationService.getValue(NotebookSetting.outlineShowCodeCells);
+            }
+            if (e.affectsConfiguration(NotebookSetting.outlineShowCodeCellSymbols)) {
+                this.showCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+            }
+            if (e.affectsConfiguration(NotebookSetting.outlineShowMarkdownHeadersOnly)) {
+                this.showMarkdownHeadersOnly = this._configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
+            }
+        }));
+    }
+    getActiveEntry() {
+        const newActive = this.outlineDataSourceRef?.object?.activeElement;
+        if (!newActive) {
+            return undefined;
+        }
+        if (!this.filterEntry(newActive)) {
+            return newActive;
+        }
+        let parent = newActive.parent;
+        while (parent) {
+            if (this.filterEntry(parent)) {
+                parent = parent.parent;
+            }
+            else {
+                return parent;
+            }
+        }
+        return undefined;
+    }
+    filterEntry(entry) {
+        if ((this.showMarkdownHeadersOnly && entry.cell.cellKind === CellKind.Markup && entry.level === NotebookOutlineConstants.NonHeaderOutlineLevel) ||
+            (!this.showCodeCells && entry.cell.cellKind === CellKind.Code) ||
+            (!this.showCodeCellSymbols && entry.cell.cellKind === CellKind.Code && entry.level > NotebookOutlineConstants.NonHeaderOutlineLevel)
+        ) {
+            return true;
+        }
+        return false;
     }
     *getChildren(element) {
-        const showCodeCells = this._configurationService.getValue(NotebookSetting.outlineShowCodeCells);
-        const showCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
-        const showMarkdownHeadersOnly = this._configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
         const isOutline = element instanceof NotebookCellOutline;
-        const entries = isOutline ? this._getEntries() : element.children;
+        const entries = isOutline ? this.outlineDataSourceRef?.object?.entries ?? [] : element.children;
         for (const entry of entries) {
             if (entry.cell.cellKind === CellKind.Markup) {
-                if (!showMarkdownHeadersOnly) {
+                if (!this.showMarkdownHeadersOnly) {
                     yield entry;
                 }
                 else if (entry.level < NotebookOutlineConstants.NonHeaderOutlineLevel) {
                     yield entry;
                 }
             }
-            else if (showCodeCells && entry.cell.cellKind === CellKind.Code) {
-                if (showCodeCellSymbols) {
+            else if (this.showCodeCells && entry.cell.cellKind === CellKind.Code) {
+                if (this.showCodeCellSymbols) {
                     yield entry;
                 }
                 else if (entry.level === NotebookOutlineConstants.NonHeaderOutlineLevel) {
@@ -335,27 +388,39 @@ let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
             }
         }
     }
+    dispose() {
+        this._disposables.dispose();
+    }
 };
 NotebookOutlinePaneProvider = ( (__decorate([
     ( (__param(1, IConfigurationService)))
 ], NotebookOutlinePaneProvider)));
 let NotebookBreadcrumbsProvider = class NotebookBreadcrumbsProvider {
-    constructor(_getActiveElement, _configurationService) {
-        this._getActiveElement = _getActiveElement;
+    constructor(outlineDataSourceRef, _configurationService) {
+        this.outlineDataSourceRef = outlineDataSourceRef;
         this._configurationService = _configurationService;
+        this._disposables = ( (new DisposableStore()));
+        this.showCodeCells = this._configurationService.getValue(NotebookSetting.breadcrumbsShowCodeCells);
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.breadcrumbsShowCodeCells)) {
+                this.showCodeCells = this._configurationService.getValue(NotebookSetting.breadcrumbsShowCodeCells);
+            }
+        }));
     }
     getBreadcrumbElements() {
         const result = [];
-        const showCodeCells = this._configurationService.getValue(NotebookSetting.breadcrumbsShowCodeCells);
-        let candidate = this._getActiveElement();
+        let candidate = this.outlineDataSourceRef?.object?.activeElement;
         while (candidate) {
-            if (showCodeCells || candidate.cell.cellKind !== CellKind.Code) {
+            if (this.showCodeCells || candidate.cell.cellKind !== CellKind.Code) {
                 result.unshift(candidate);
             }
             candidate = candidate.parent;
         }
         return result;
     }
+    dispose() {
+        this._disposables.dispose();
+    }
 };
 NotebookBreadcrumbsProvider = ( (__decorate([
     ( (__param(1, IConfigurationService)))
@@ -375,46 +440,58 @@ class NotebookComparator {
     }
 }
 let NotebookCellOutline = class NotebookCellOutline {
+    get activeElement() {
+        this.checkDelayer();
+        if (this._target === OutlineTarget.OutlinePane) {
+            return this.config.treeDataSource.getActiveEntry();
+        }
+        else {
+            console.error('activeElement should not be called outside of the OutlinePane');
+            return undefined;
+        }
+    }
     get entries() {
-        return this._outlineProviderReference?.object?.entries ?? [];
+        this.checkDelayer();
+        return this._outlineDataSourceReference?.object?.entries ?? [];
     }
-    get activeElement() {
-        return this._outlineProviderReference?.object?.activeElement;
+    get uri() {
+        return this._outlineDataSourceReference?.object?.uri;
+    }
+    get isEmpty() {
+        return this._outlineDataSourceReference?.object?.isEmpty ?? true;
+    }
+    checkDelayer() {
+        if (this.delayerRecomputeState.isTriggered()) {
+            this.delayerRecomputeState.cancel();
+            this.recomputeState();
+        }
     }
-    constructor(_editor, _target, instantiationService, _editorService, _configurationService) {
+    constructor(_editor, _target, _themeService, _editorService, _instantiationService, _configurationService, _languageFeaturesService, _notebookExecutionStateService) {
         this._editor = _editor;
+        this._target = _target;
+        this._themeService = _themeService;
         this._editorService = _editorService;
-        this._dispoables = ( (new DisposableStore()));
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this.outlineKind = 'notebookCells';
+        this._disposables = ( (new DisposableStore()));
+        this._modelDisposables = ( (new DisposableStore()));
+        this._dataSourceDisposables = ( (new DisposableStore()));
         this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this._entriesDisposables = ( (new DisposableStore()));
-        this.outlineKind = 'notebookCells';
-        this._localDisposables = ( (new DisposableStore()));
-        const installSelectionListener = () => {
-            const notebookEditor = _editor.getControl();
-            if (!notebookEditor?.hasModel()) {
-                this._outlineProviderReference?.dispose();
-                this._outlineProviderReference = undefined;
-                this._localDisposables.clear();
-            }
-            else {
-                this._outlineProviderReference?.dispose();
-                this._localDisposables.clear();
-                this._outlineProviderReference = instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineProviderFactory).getOrCreate(notebookEditor, _target));
-                this._localDisposables.add(this._outlineProviderReference.object.onDidChange(e => {
-                    this._onDidChange.fire(e);
-                }));
-            }
-        };
-        this._dispoables.add(_editor.onDidChangeModel(() => {
-            installSelectionListener();
-        }));
-        installSelectionListener();
+        this.delayerRecomputeState = this._disposables.add(( (new Delayer(300))));
+        this.delayerRecomputeActive = this._disposables.add(( (new Delayer(200))));
+        this.delayerRecomputeSymbols = this._disposables.add(( (new Delayer(2000))));
+        this.gotoShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+        this.outlineShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+        this.initializeOutline();
         const delegate = ( (new NotebookOutlineVirtualDelegate()));
-        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), _target)];
+        const renderers = [this._instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), this._target)];
         const comparator = ( (new NotebookComparator()));
         const options = {
-            collapseByDefault: _target === OutlineTarget.Breadcrumbs || (_target === OutlineTarget.OutlinePane && _configurationService.getValue(OutlineConfigKeys.collapseItems) === OutlineConfigCollapseItemsValues.Collapsed),
+            collapseByDefault: this._target === OutlineTarget.Breadcrumbs || (this._target === OutlineTarget.OutlinePane && this._configurationService.getValue(OutlineConfigKeys.collapseItems) === OutlineConfigCollapseItemsValues.Collapsed),
             expandOnlyOnTwistieClick: true,
             multipleSelectionSupport: false,
             accessibilityProvider: ( (new NotebookOutlineAccessibility())),
@@ -422,33 +499,121 @@ let NotebookCellOutline = class NotebookCellOutline {
             keyboardNavigationLabelProvider: ( (new NotebookNavigationLabelProvider()))
         };
         this.config = {
-            treeDataSource: instantiationService.createInstance(NotebookOutlinePaneProvider, () => (this.entries ?? [])),
-            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this.entries ?? [])),
-            breadcrumbsDataSource: instantiationService.createInstance(NotebookBreadcrumbsProvider, () => (this.activeElement)),
+            treeDataSource: this._treeDataSource,
+            quickPickDataSource: this._quickPickDataSource,
+            breadcrumbsDataSource: this._breadcrumbsDataSource,
             delegate,
             renderers,
             comparator,
             options
         };
     }
-    async setFullSymbols(cancelToken) {
-        await this._outlineProviderReference?.object?.setFullSymbols(cancelToken);
+    initializeOutline() {
+        this.setDataSources();
+        this.setModelListeners();
+        this._disposables.add(this._editor.onDidChangeModel(() => {
+            this.setDataSources();
+            this.setModelListeners();
+            this.computeSymbols();
+        }));
+        this._disposables.add(this._languageFeaturesService.documentSymbolProvider.onDidChange(() => {
+            this.delayedComputeSymbols();
+        }));
+        this._disposables.add(this._editor.onDidChangeSelection(() => {
+            this.delayedRecomputeActive();
+        }));
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.outlineShowMarkdownHeadersOnly) ||
+                e.affectsConfiguration(NotebookSetting.outlineShowCodeCells) ||
+                e.affectsConfiguration(NotebookSetting.outlineShowCodeCellSymbols) ||
+                e.affectsConfiguration(NotebookSetting.breadcrumbsShowCodeCells)) {
+                this.delayedRecomputeState();
+            }
+        }));
+        this._disposables.add(this._notebookExecutionStateService.onDidChangeExecution(e => {
+            if (e.type === NotebookExecutionType.cell && !!this._editor.textModel && e.affectsNotebook(this._editor.textModel?.uri)) {
+                this.delayedRecomputeState();
+            }
+        }));
+        this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.gotoSymbolsAllSymbols) || e.affectsConfiguration(NotebookSetting.outlineShowCodeCellSymbols)) {
+                this.gotoShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
+                this.outlineShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
+                this.computeSymbols();
+            }
+        }));
+        this._disposables.add(this._themeService.onDidFileIconThemeChange(() => {
+            this._onDidChange.fire({});
+        }));
+        this.recomputeState();
+    }
+    setDataSources() {
+        const notebookEditor = this._editor.getControl();
+        this._outlineDataSourceReference?.dispose();
+        this._dataSourceDisposables.clear();
+        if (!notebookEditor?.hasModel()) {
+            this._outlineDataSourceReference = undefined;
+        }
+        else {
+            this._outlineDataSourceReference = this._dataSourceDisposables.add(this._instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineDataSourceFactory).getOrCreate(notebookEditor)));
+            this._dataSourceDisposables.add(this._outlineDataSourceReference.object.onDidChange(() => {
+                this._onDidChange.fire({});
+            }));
+        }
+        this._treeDataSource = this._dataSourceDisposables.add(this._instantiationService.createInstance(NotebookOutlinePaneProvider, this._outlineDataSourceReference));
+        this._quickPickDataSource = this._dataSourceDisposables.add(this._instantiationService.createInstance(NotebookQuickPickProvider, this._outlineDataSourceReference));
+        this._breadcrumbsDataSource = this._dataSourceDisposables.add(this._instantiationService.createInstance(NotebookBreadcrumbsProvider, this._outlineDataSourceReference));
+    }
+    setModelListeners() {
+        this._modelDisposables.clear();
+        if (!this._editor.textModel) {
+            return;
+        }
+        if (!this.entries.length) {
+            this.computeSymbols();
+        }
+        this._modelDisposables.add(this._editor.textModel.onDidChangeContent(contentChanges => {
+            if (( (contentChanges.rawEvents.some(c => c.kind === NotebookCellsChangeType.ChangeCellContent ||
+                c.kind === NotebookCellsChangeType.ChangeCellInternalMetadata ||
+                c.kind === NotebookCellsChangeType.Move ||
+                c.kind === NotebookCellsChangeType.ModelChange)))) {
+                this.delayedRecomputeState();
+            }
+        }));
     }
-    get uri() {
-        return this._outlineProviderReference?.object?.uri;
+    async computeSymbols(cancelToken = CancellationToken.None) {
+        if (this._target === OutlineTarget.QuickPick && this.gotoShowCodeCellSymbols) {
+            await this._outlineDataSourceReference?.object?.computeFullSymbols(cancelToken);
+        }
+        else if (this._target === OutlineTarget.OutlinePane && this.outlineShowCodeCellSymbols) {
+            void this._outlineDataSourceReference?.object?.computeFullSymbols(cancelToken);
+        }
     }
-    get isEmpty() {
-        return this._outlineProviderReference?.object?.isEmpty ?? true;
+    async delayedComputeSymbols() {
+        this.delayerRecomputeState.cancel();
+        this.delayerRecomputeActive.cancel();
+        this.delayerRecomputeSymbols.trigger(() => { this.computeSymbols(); });
+    }
+    recomputeState() { this._outlineDataSourceReference?.object?.recomputeState(); }
+    delayedRecomputeState() {
+        this.delayerRecomputeActive.cancel();
+        this.delayerRecomputeState.trigger(() => { this.recomputeState(); });
+    }
+    recomputeActive() { this._outlineDataSourceReference?.object?.recomputeActive(); }
+    delayedRecomputeActive() {
+        this.delayerRecomputeActive.trigger(() => { this.recomputeActive(); });
     }
     async reveal(entry, options, sideBySide) {
+        const notebookEditorOptions = {
+            ...options,
+            override: this._editor.input?.editorId,
+            cellRevealType: CellRevealType.NearTopIfOutsideViewport,
+            selection: entry.position,
+            viewState: undefined,
+        };
         await this._editorService.openEditor({
             resource: entry.cell.uri,
-            options: {
-                ...options,
-                override: this._editor.input?.editorId,
-                cellRevealType: CellRevealType.NearTopIfOutsideViewport,
-                selection: entry.position
-            },
+            options: notebookEditorOptions,
         }, sideBySide ? SIDE_GROUP : undefined);
     }
     preview(entry) {
@@ -506,21 +671,23 @@ let NotebookCellOutline = class NotebookCellOutline {
     }
     dispose() {
         this._onDidChange.dispose();
-        this._dispoables.dispose();
-        this._entriesDisposables.dispose();
-        this._outlineProviderReference?.dispose();
-        this._localDisposables.dispose();
+        this._disposables.dispose();
+        this._modelDisposables.dispose();
+        this._dataSourceDisposables.dispose();
+        this._outlineDataSourceReference?.dispose();
     }
 };
 NotebookCellOutline = ( (__decorate([
-    ( (__param(2, IInstantiationService))),
+    ( (__param(2, IThemeService))),
     ( (__param(3, IEditorService))),
-    ( (__param(4, IConfigurationService)))
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ILanguageFeaturesService))),
+    ( (__param(7, INotebookExecutionStateService)))
 ], NotebookCellOutline)));
 let NotebookOutlineCreator = class NotebookOutlineCreator {
-    constructor(outlineService, _instantiationService, _configurationService) {
+    constructor(outlineService, _instantiationService) {
         this._instantiationService = _instantiationService;
-        this._configurationService = _configurationService;
         const reg = outlineService.registerOutlineCreator(this);
         this.dispose = () => reg.dispose();
     }
@@ -528,22 +695,12 @@ let NotebookOutlineCreator = class NotebookOutlineCreator {
         return candidate.getId() === NotebookEditor.ID;
     }
     async createOutline(editor, target, cancelToken) {
-        const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
-        const showAllGotoSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
-        const showAllOutlineSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
-        if (target === OutlineTarget.QuickPick && showAllGotoSymbols) {
-            await outline.setFullSymbols(cancelToken);
-        }
-        else if (target === OutlineTarget.OutlinePane && showAllOutlineSymbols) {
-            void outline.setFullSymbols(cancelToken);
-        }
-        return outline;
+        return this._instantiationService.createInstance(NotebookCellOutline, editor, target);
     }
 };
 NotebookOutlineCreator = ( (__decorate([
     ( (__param(0, IOutlineService))),
-    ( (__param(1, IInstantiationService))),
-    ( (__param(2, IConfigurationService)))
+    ( (__param(1, IInstantiationService)))
 ], NotebookOutlineCreator)));
 const NotebookOutlineContext = {
     CellKind: ( (new RawContextKey('notebookCellKind', undefined))),

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.js

@@ -448,7 +448,7 @@ class CodeActionParticipantUtils {
             }
         });
         for (const codeActionKind of codeActionsOnSave) {
-            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, getActionProgress, token);
+            const actionsToRun = await CodeActionParticipantUtils.getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, getActionProgress, token);
             if (token.isCancellationRequested) {
                 actionsToRun.dispose();
                 return;

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/apiActions.js

@@ -39,7 +39,7 @@ CommandsRegistry.registerCommand('_resolveNotebookContentProvider', (accessor) =
 CommandsRegistry.registerCommand('_resolveNotebookKernels', async (accessor, args) => {
     const notebookKernelService = accessor.get(INotebookKernelService);
     const uri = URI.revive(args.uri);
-    const kernels = notebookKernelService.getMatchingKernel({ uri, viewType: args.viewType });
+    const kernels = notebookKernelService.getMatchingKernel({ uri, notebookType: args.viewType });
     return ( kernels.all.map(provider => ({
         id: provider.id,
         label: provider.label,

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/cellChatActions.js

@@ -9,8 +9,8 @@ import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/c
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { InputFocusedContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
 import { KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
-import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, CTX_INLINE_CHAT_RESPONSE_TYPES, InlineChatResponseTypes, CTX_INLINE_CHAT_HAS_AGENT } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import { CTX_NOTEBOOK_CELL_CHAT_FOCUSED, MENU_CELL_CHAT_INPUT, CTX_NOTEBOOK_CHAT_HAS_ACTIVE_REQUEST, MENU_CELL_CHAT_WIDGET, CTX_NOTEBOOK_CHAT_USER_DID_EDIT, CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION, MENU_CELL_CHAT_WIDGET_STATUS } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, CTX_INLINE_CHAT_RESPONSE_TYPE, InlineChatResponseType } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { CTX_NOTEBOOK_CELL_CHAT_FOCUSED, MENU_CELL_CHAT_INPUT, CTX_NOTEBOOK_CHAT_HAS_ACTIVE_REQUEST, MENU_CELL_CHAT_WIDGET, CTX_NOTEBOOK_CHAT_USER_DID_EDIT, CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION, MENU_CELL_CHAT_WIDGET_STATUS, CTX_NOTEBOOK_CHAT_HAS_AGENT } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext';
 import { NotebookChatController } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController';
 import { NotebookAction, NotebookCellAction, getEditorFromArgsOrActivePane, CELL_TITLE_CELL_GROUP_ID } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
 import { insertNewCell } from '../insertCellActions.js';
@@ -240,9 +240,9 @@ registerAction2(class extends NotebookAction {
             menu: [
                 {
                     id: MENU_CELL_CHAT_WIDGET_STATUS,
-                    group: 'inline',
+                    group: '0_main',
                     order: 0,
-                    when: ( (CTX_INLINE_CHAT_RESPONSE_TYPES.notEqualsTo(InlineChatResponseTypes.OnlyMessages))),
+                    when: ( (CTX_INLINE_CHAT_RESPONSE_TYPE.notEqualsTo(InlineChatResponseType.Messages))),
                 }
             ],
             f1: false
@@ -270,7 +270,7 @@ registerAction2(class extends NotebookAction {
             },
             menu: {
                 id: MENU_CELL_CHAT_WIDGET_STATUS,
-                group: 'main',
+                group: '0_main',
                 order: 1
             },
             f1: false
@@ -339,7 +339,7 @@ registerAction2(class extends NotebookAction {
                     NOTEBOOK_EDITOR_FOCUSED,
                      (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
                     ContextKeyExpr.not(InputFocusedContextKey),
-                    CTX_INLINE_CHAT_HAS_AGENT,
+                    CTX_NOTEBOOK_CHAT_HAS_AGENT,
                      (ContextKeyExpr.or(
                          (ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)),
                          (ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))
@@ -356,7 +356,7 @@ registerAction2(class extends NotebookAction {
                     order: -1,
                     when: ( (ContextKeyExpr.and(
                          (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
-                        CTX_INLINE_CHAT_HAS_AGENT,
+                        CTX_NOTEBOOK_CHAT_HAS_AGENT,
                          (ContextKeyExpr.or(
                              (ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)),
                              (ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))
@@ -421,7 +421,7 @@ registerAction2(class extends NotebookAction {
                     order: -1,
                     when: ( (ContextKeyExpr.and(
                          (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
-                        CTX_INLINE_CHAT_HAS_AGENT,
+                        CTX_NOTEBOOK_CHAT_HAS_AGENT,
                          (ContextKeyExpr.or(
                              (ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)),
                              (ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))
@@ -448,7 +448,7 @@ MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
          (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
          (ContextKeyExpr.notEquals('config.notebook.insertToolbarLocation', 'betweenCells')),
          (ContextKeyExpr.notEquals('config.notebook.insertToolbarLocation', 'hidden')),
-        CTX_INLINE_CHAT_HAS_AGENT,
+        CTX_NOTEBOOK_CHAT_HAS_AGENT,
          (ContextKeyExpr.or(
              (ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)),
              (ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))
@@ -573,7 +573,7 @@ registerAction2(class extends NotebookCellAction {
                 order: 0,
                 when: ( (ContextKeyExpr.and(
                      (NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)),
-                    CTX_INLINE_CHAT_HAS_AGENT,
+                    CTX_NOTEBOOK_CHAT_HAS_AGENT,
                     NOTEBOOK_CELL_GENERATED_BY_CHAT,
                      (ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true))
                 )))

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebook.chat.contribution.js

@@ -1,14 +1,18 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
 import './cellChatActions.js';
+import { CTX_NOTEBOOK_CHAT_HAS_AGENT } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext';
 import { NotebookChatController } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController';
 import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
 
-let NotebookChatVariables = class NotebookChatVariables extends Disposable {
-    static { this.ID = 'workbench.contrib.notebookChatVariables'; }
-    constructor(_chatVariableService, _notebookEditorService) {
+let NotebookChatContribution = class NotebookChatContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.notebookChatContribution'; }
+    constructor(_chatVariableService, _notebookEditorService, contextKeyService, chatAgentService) {
         super();
         this._chatVariableService = _chatVariableService;
         this._notebookEditorService = _notebookEditorService;
@@ -22,10 +26,19 @@ let NotebookChatVariables = class NotebookChatVariables extends Disposable {
             }
             return undefined;
         }));
+        this._ctxHasProvider = CTX_NOTEBOOK_CHAT_HAS_AGENT.bindTo(contextKeyService);
+        const updateNotebookAgentStatus = () => {
+            const hasNotebookAgent = Boolean(chatAgentService.getDefaultAgent(ChatAgentLocation.Notebook));
+            this._ctxHasProvider.set(hasNotebookAgent);
+        };
+        updateNotebookAgentStatus();
+        this._register(chatAgentService.onDidChangeAgents(updateNotebookAgentStatus));
     }
 };
-NotebookChatVariables = ( __decorate([
+NotebookChatContribution = ( __decorate([
     ( __param(0, IChatVariablesService)),
-    ( __param(1, INotebookEditorService))
-], NotebookChatVariables));
-registerWorkbenchContribution2(NotebookChatVariables.ID, NotebookChatVariables, WorkbenchPhase.BlockRestore);
+    ( __param(1, INotebookEditorService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IChatAgentService))
+], NotebookChatContribution));
+registerWorkbenchContribution2(NotebookChatContribution.ID, NotebookChatContribution, WorkbenchPhase.BlockRestore);

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffElementOutputs.js

@@ -150,7 +150,7 @@ class OutputElement extends Disposable {
             this.resizeListener.clear();
             const element = this.domNode;
             if (element) {
-                element.parentElement?.removeChild(element);
+                element.remove();
                 this._notebookEditor.removeInset(this._diffElementViewModel, this._nestedCell, viewModel, this._diffSide);
             }
             viewModel.pickedMimeType = mimeTypes[pick];
@@ -208,7 +208,7 @@ let OutputContainer = class OutputContainer extends Disposable {
         this._outputEntries.forEach((value, key) => {
             if (this._nestedCellViewModel.outputsViewModels.indexOf(key) < 0) {
                 removedKeys.push(key);
-                this._outputContainer.removeChild(value.domNode);
+                value.domNode.remove();
                 this._editor.removeInset(this._diffElementViewModel, this._nestedCellViewModel, key, this._diffSide);
             }
         });