@codingame/monaco-vscode-notebook-service-override 11.1.2 → 12.0.0

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { clearNode, WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
 import { ToolBar } from 'vscode/vscode/vs/base/browser/ui/toolbar/toolbar';
@@ -26,10 +27,13 @@ import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 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 { CellFoldingState, CellRevealType } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NotebookEditor } from '@codingame/monaco-vscode-6f9bc782-77e0-5716-93bd-b05210c768c5-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
 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 '@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common/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';
@@ -39,13 +43,14 @@ import { MenuItemAction, MenuId, MenuRegistry, registerAction2, Action2 } from '
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 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 { MenuEntryActionViewItem, getActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
 import { disposableTimeout, Delayer } from 'vscode/vscode/vs/base/common/async';
-import { IOutlinePane } from 'vscode/vscode/vs/workbench/contrib/outline/browser/outline';
+import { IOutlinePane } from '@codingame/monaco-vscode-0cd5242b-7b61-5f66-ac25-ffa40baf8e8f-common/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 { INotebookCellOutlineDataSourceFactory } from '@codingame/monaco-vscode-chat-interactive-notebook-search-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.service';
-import { NotebookExecutionType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { NOTEBOOK_IS_ACTIVE_EDITOR } from '@codingame/monaco-vscode-4a36e358-d94d-55e0-86ee-3bcd543d9d3f-common/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { NotebookOutlineConstants } from '../../viewModel/notebookOutlineEntryFactory.js';
+import { INotebookCellOutlineDataSourceFactory } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.service';
+import { NotebookExecutionType } from '@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/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';
 
@@ -73,27 +78,25 @@ 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 = [];
@@ -119,7 +122,7 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
         template.decoration.innerText = '';
         if (markerInfo) {
             const problem = this._configurationService.getValue('problems.visibility');
-            const useBadges = this._configurationService.getValue("outline.problems.badges" );
+            const useBadges = this._configurationService.getValue(OutlineConfigKeys.problemsBadges);
             if (!useBadges || !problem) {
                 template.decoration.classList.remove('bubble');
                 template.decoration.innerText = '';
@@ -136,7 +139,7 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
             if (problem === undefined) {
                 return;
             }
-            const useColors = this._configurationService.getValue("outline.problems.colors" );
+            const useColors = this._configurationService.getValue(OutlineConfigKeys.problemsColors);
             if (!useColors || !problem) {
                 template.container.style.removeProperty('--outline-element-color');
                 template.decoration.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
@@ -145,9 +148,12 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
                 template.container.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
             }
         }
-        if (this._target === 1 ) {
+        if (this._target === OutlineTarget.OutlinePane) {
+            if (!this._editor) {
+                return;
+            }
             const nbCell = node.element.cell;
-            const nbViewModel = this._editor?.getViewModel();
+            const nbViewModel = this._editor.getViewModel();
             if (!nbViewModel) {
                 return;
             }
@@ -156,21 +162,21 @@ 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 !== NotebookOutlineConstants.NonHeaderOutlineLevel);
             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);
-            this.setupToolbarListeners(outlineEntryToolbar, menu, actions, node.element, template);
+            this.setupToolbarListeners(this._editor, outlineEntryToolbar, menu, actions, node.element, template);
             template.actionMenu.style.padding = '0 0.8em 0 0.4em';
         }
     }
@@ -183,7 +189,7 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
         clearNode(templateData.actionMenu);
     }
     setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell) {
-        const foldingState = isCodeCell ? 0  : (nbCell.foldingState);
+        const foldingState = isCodeCell ? CellFoldingState.None : (nbCell.foldingState);
         const foldingStateCtx = NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService);
         foldingStateCtx.set(foldingState);
         if (!isCodeCell) {
@@ -194,17 +200,17 @@ let NotebookOutlineRenderer = class NotebookOutlineRenderer {
             }));
         }
     }
-    setupToolbarListeners(toolbar, menu, initActions, entry, templateData) {
+    setupToolbarListeners(editor, toolbar, menu, initActions, entry, templateData) {
         let dropdownIsVisible = false;
         let deferredUpdate;
         toolbar.setActions(initActions.primary, initActions.secondary);
         templateData.elementDisposables.add(menu.onDidChange(() => {
             if (dropdownIsVisible) {
-                const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+                const actions = getOutlineToolbarActions(menu, { notebookEditor: editor, outlineEntry: entry });
                 deferredUpdate = () => toolbar.setActions(actions.primary, actions.secondary);
                 return;
             }
-            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
+            const actions = getOutlineToolbarActions(menu, { notebookEditor: editor, outlineEntry: entry });
             toolbar.setActions(actions.primary, actions.secondary);
         }));
         templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
@@ -225,20 +231,16 @@ 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 = [];
-    const result = { primary, secondary };
-    createAndFillInActionBarActions(menu, { shouldForwardArgs: true, arg: args }, result);
-    return result;
+    return getActionBarActions(menu.getActions({ shouldForwardArgs: true, arg: args }), g => /^inline/.test(g));
 }
 class NotebookOutlineAccessibility {
     getAriaLabel(element) {
@@ -266,7 +268,7 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         this.notebookCellOutlineDataSourceRef = notebookCellOutlineDataSourceRef;
         this._configurationService = _configurationService;
         this._themeService = _themeService;
-        this._disposables = ( (new DisposableStore()));
+        this._disposables = ( new DisposableStore());
         this.gotoShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
         this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(NotebookSetting.gotoSymbolsAllSymbols)) {
@@ -282,7 +284,7 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         const result = [];
         const { hasFileIcons } = this._themeService.getFileIconTheme();
         const isSymbol = (element) => !!element.symbolKind;
-        const isCodeCell = (element) => ((element.cell.cellKind === CellKind.Code && element.level === 7) );
+        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];
@@ -309,15 +311,15 @@ let NotebookQuickPickProvider = class NotebookQuickPickProvider {
         this._disposables.dispose();
     }
 };
-NotebookQuickPickProvider = ( (__decorate([
-    ( (__param(1, IConfigurationService))),
-    ( (__param(2, IThemeService)))
-], NotebookQuickPickProvider)));
+NotebookQuickPickProvider = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IThemeService))
+], NotebookQuickPickProvider));
 let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
     constructor(outlineDataSourceRef, _configurationService) {
         this.outlineDataSourceRef = outlineDataSourceRef;
         this._configurationService = _configurationService;
-        this._disposables = ( (new DisposableStore()));
+        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);
@@ -353,9 +355,9 @@ let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
         return undefined;
     }
     filterEntry(entry) {
-        if (((this.showMarkdownHeadersOnly && entry.cell.cellKind === CellKind.Markup && entry.level === 7) ) ||
+        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 > 7) )
+            (!this.showCodeCellSymbols && entry.cell.cellKind === CellKind.Code && entry.level > NotebookOutlineConstants.NonHeaderOutlineLevel)
         ) {
             return true;
         }
@@ -369,7 +371,7 @@ let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
                 if (!this.showMarkdownHeadersOnly) {
                     yield entry;
                 }
-                else if (entry.level < 7 ) {
+                else if (entry.level < NotebookOutlineConstants.NonHeaderOutlineLevel) {
                     yield entry;
                 }
             }
@@ -377,7 +379,7 @@ let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
                 if (this.showCodeCellSymbols) {
                     yield entry;
                 }
-                else if (entry.level === 7 ) {
+                else if (entry.level === NotebookOutlineConstants.NonHeaderOutlineLevel) {
                     yield entry;
                 }
             }
@@ -387,14 +389,14 @@ let NotebookOutlinePaneProvider = class NotebookOutlinePaneProvider {
         this._disposables.dispose();
     }
 };
-NotebookOutlinePaneProvider = ( (__decorate([
-    ( (__param(1, IConfigurationService)))
-], NotebookOutlinePaneProvider)));
+NotebookOutlinePaneProvider = ( __decorate([
+    ( __param(1, IConfigurationService))
+], NotebookOutlinePaneProvider));
 let NotebookBreadcrumbsProvider = class NotebookBreadcrumbsProvider {
     constructor(outlineDataSourceRef, _configurationService) {
         this.outlineDataSourceRef = outlineDataSourceRef;
         this._configurationService = _configurationService;
-        this._disposables = ( (new DisposableStore()));
+        this._disposables = ( new DisposableStore());
         this.showCodeCells = this._configurationService.getValue(NotebookSetting.breadcrumbsShowCodeCells);
         this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(NotebookSetting.breadcrumbsShowCodeCells)) {
@@ -417,9 +419,9 @@ let NotebookBreadcrumbsProvider = class NotebookBreadcrumbsProvider {
         this._disposables.dispose();
     }
 };
-NotebookBreadcrumbsProvider = ( (__decorate([
-    ( (__param(1, IConfigurationService)))
-], NotebookBreadcrumbsProvider)));
+NotebookBreadcrumbsProvider = ( __decorate([
+    ( __param(1, IConfigurationService))
+], NotebookBreadcrumbsProvider));
 class NotebookComparator {
     constructor() {
         this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
@@ -437,7 +439,7 @@ class NotebookComparator {
 let NotebookCellOutline = class NotebookCellOutline {
     get activeElement() {
         this.checkDelayer();
-        if (this._target === 1 ) {
+        if (this._target === OutlineTarget.OutlinePane) {
             return this.config.treeDataSource.getActiveEntry();
         }
         else {
@@ -471,26 +473,26 @@ let NotebookCellOutline = class NotebookCellOutline {
         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._disposables = ( new DisposableStore());
+        this._modelDisposables = ( new DisposableStore());
+        this._dataSourceDisposables = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
-        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.delayerRecomputeState = this._disposables.add(( new Delayer(300)));
+        this.delayerRecomputeActive = this._disposables.add(( new Delayer(200)));
+        this.delayerRecomputeSymbols = this._disposables.add(( new Delayer(2000)));
         this.outlineShowCodeCellSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
         this.initializeOutline();
-        const delegate = ( (new NotebookOutlineVirtualDelegate()));
+        const delegate = ( new NotebookOutlineVirtualDelegate());
         const renderers = [this._instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), this._target)];
-        const comparator = ( (new NotebookComparator()));
+        const comparator = ( new NotebookComparator());
         const options = {
-            collapseByDefault: this._target === 2  || ((this._target === 1  && this._configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
+            collapseByDefault: this._target === OutlineTarget.Breadcrumbs || (this._target === OutlineTarget.OutlinePane && this._configurationService.getValue(OutlineConfigKeys.collapseItems) === OutlineConfigCollapseItemsValues.Collapsed),
             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 = {
             treeDataSource: this._treeDataSource,
@@ -566,16 +568,16 @@ let NotebookCellOutline = class NotebookCellOutline {
             this.computeSymbols();
         }
         this._modelDisposables.add(this._editor.textModel.onDidChangeContent(contentChanges => {
-            if (( (contentChanges.rawEvents.some(c => c.kind === NotebookCellsChangeType.ChangeCellContent ||
+            if (( contentChanges.rawEvents.some(c => c.kind === NotebookCellsChangeType.ChangeCellContent ||
                 c.kind === NotebookCellsChangeType.ChangeCellInternalMetadata ||
                 c.kind === NotebookCellsChangeType.Move ||
-                c.kind === NotebookCellsChangeType.ModelChange)))) {
+                c.kind === NotebookCellsChangeType.ModelChange))) {
                 this.delayedRecomputeState();
             }
         }));
     }
     async computeSymbols(cancelToken = CancellationToken.None) {
-        if (this._target === 1  && this.outlineShowCodeCellSymbols) {
+        if (this._target === OutlineTarget.OutlinePane && this.outlineShowCodeCellSymbols) {
             void this.doComputeSymbols(cancelToken);
         }
     }
@@ -600,7 +602,7 @@ let NotebookCellOutline = class NotebookCellOutline {
         const notebookEditorOptions = {
             ...options,
             override: this._editor.input?.editorId,
-            cellRevealType: 5 ,
+            cellRevealType: CellRevealType.NearTopIfOutsideViewport,
             selection: entry.position,
             viewState: undefined,
         };
@@ -670,14 +672,14 @@ let NotebookCellOutline = class NotebookCellOutline {
         this._outlineDataSourceReference?.dispose();
     }
 };
-NotebookCellOutline = ( (__decorate([
-    ( (__param(2, IThemeService))),
-    ( (__param(3, IEditorService))),
-    ( (__param(4, IInstantiationService))),
-    ( (__param(5, IConfigurationService))),
-    ( (__param(6, ILanguageFeaturesService))),
-    ( (__param(7, INotebookExecutionStateService)))
-], NotebookCellOutline)));
+NotebookCellOutline = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ILanguageFeaturesService)),
+    ( __param(7, INotebookExecutionStateService))
+], NotebookCellOutline));
 let NotebookOutlineCreator = class NotebookOutlineCreator {
     constructor(outlineService, _instantiationService) {
         this._instantiationService = _instantiationService;
@@ -689,25 +691,25 @@ let NotebookOutlineCreator = class NotebookOutlineCreator {
     }
     async createOutline(editor, target, cancelToken) {
         const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
-        if (target === 4 ) {
+        if (target === OutlineTarget.QuickPick) {
             await outline.doComputeSymbols(cancelToken);
         }
         return outline;
     }
 };
-NotebookOutlineCreator = ( (__decorate([
-    ( (__param(0, IOutlineService))),
-    ( (__param(1, IInstantiationService)))
-], NotebookOutlineCreator)));
+NotebookOutlineCreator = ( __decorate([
+    ( __param(0, IOutlineService)),
+    ( __param(1, IInstantiationService))
+], 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', CellFoldingState.None)),
+    OutlineElementTarget: ( new RawContextKey('notebookOutlineElementTarget', undefined)),
 };
-( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
-( (Registry.as(Extensions$1.Configuration))).registerConfiguration({
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, LifecyclePhase.Eventually);
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
     id: 'notebook',
     order: 100,
     type: 'object',
@@ -716,33 +718,33 @@ const NotebookOutlineContext = {
             type: 'boolean',
             default: true,
             markdownDescription: ( localize(
-                8148,
+                7384,
                 "When enabled, notebook outline will show only markdown cells containing a header."
             ))
         },
         [NotebookSetting.outlineShowCodeCells]: {
             type: 'boolean',
             default: false,
-            markdownDescription: ( localize(8149, "When enabled, notebook outline shows code cells."))
+            markdownDescription: ( localize(7385, "When enabled, notebook outline shows code cells."))
         },
         [NotebookSetting.outlineShowCodeCellSymbols]: {
             type: 'boolean',
             default: true,
             markdownDescription: ( localize(
-                8150,
+                7386,
                 "When enabled, notebook outline shows code cell symbols. Relies on `notebook.outline.showCodeCells` being enabled."
             ))
         },
         [NotebookSetting.breadcrumbsShowCodeCells]: {
             type: 'boolean',
             default: true,
-            markdownDescription: ( localize(8151, "When enabled, notebook breadcrumbs contain code cells."))
+            markdownDescription: ( localize(7387, "When enabled, notebook breadcrumbs contain code cells."))
         },
         [NotebookSetting.gotoSymbolsAllSymbols]: {
             type: 'boolean',
             default: true,
             markdownDescription: ( localize(
-                8152,
+                7388,
                 "When enabled, the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
             ))
         },
@@ -750,23 +752,20 @@ const NotebookOutlineContext = {
 });
 MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
     submenu: MenuId.NotebookOutlineFilter,
-    title: ( localize(8153, "Filter Entries")),
+    title: ( localize(7389, "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: ( localize(8154, "Markdown Headers Only")),
+            title: ( localize(7390, "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,
@@ -784,10 +783,10 @@ registerAction2(class ToggleCodeCellEntries extends Action2 {
     constructor() {
         super({
             id: 'notebook.outline.toggleCodeCells',
-            title: ( localize(8155, "Code Cells")),
+            title: ( localize(7391, "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,
@@ -806,10 +805,10 @@ registerAction2(class ToggleCodeCellSymbolEntries extends Action2 {
     constructor() {
         super({
             id: 'notebook.outline.toggleCodeCellSymbols',
-            title: ( localize(8156, "Code Cell Symbols")),
+            title: ( localize(7392, "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.d.ts

@@ -0,0 +1,8 @@
+export declare enum NotebookProfileType {
+    default = "default",
+    jupyter = "jupyter",
+    colab = "colab"
+}
+export interface ISetProfileArgs {
+    profile: NotebookProfileType;
+}

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

@@ -1,14 +1,15 @@
+
 import { localize } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 
 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,7 +53,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.setProfile',
-            title: ( localize(8157, "Set Profile"))
+            title: ( localize(7393, "Set Profile"))
         });
     }
     async run(accessor, args) {

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.d.ts

@@ -0,0 +1,32 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { HierarchicalKind } from "vscode/vscode/vs/base/common/hierarchicalKind";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { CodeActionProvider } from "vscode/vscode/vs/editor/common/languages";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { ILanguageFeaturesService } from "vscode/vscode/vs/editor/common/services/languageFeatures";
+import { IInstantiationService, ServicesAccessor } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IProgress, IProgressStep } from "vscode/vscode/vs/platform/progress/common/progress";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { NotebookTextModel } from "../../../common/model/notebookTextModel.js";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
+import { IStoredFileWorkingCopySaveParticipant, IStoredFileWorkingCopySaveParticipantContext } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+export declare abstract class NotebookSaveParticipant implements IStoredFileWorkingCopySaveParticipant {
+    private readonly _editorService;
+    constructor(_editorService: IEditorService);
+    abstract participate(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: IStoredFileWorkingCopySaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+    protected canParticipate(): boolean;
+}
+export declare class CodeActionParticipantUtils {
+    static checkAndRunFormatCodeAction(accessor: ServicesAccessor, notebookModel: NotebookTextModel, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<boolean>;
+    static applyOnSaveGenericCodeActions(accessor: ServicesAccessor, model: ITextModel, codeActionsOnSave: readonly HierarchicalKind[], excludes: readonly HierarchicalKind[], progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+    static applyOnSaveFormatCodeAction(accessor: ServicesAccessor, model: ITextModel, formatCodeActionOnSave: HierarchicalKind, excludes: readonly HierarchicalKind[], extensionId: string | undefined, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<boolean>;
+    static getActionsToRun(model: ITextModel, codeActionKind: HierarchicalKind, excludes: readonly HierarchicalKind[], languageFeaturesService: ILanguageFeaturesService, progress: IProgress<CodeActionProvider>, token: CancellationToken): Promise<import("vscode/vscode/vs/editor/contrib/codeAction/common/types").CodeActionSet>;
+}
+export declare class SaveParticipantsContribution extends Disposable implements IWorkbenchContribution {
+    private readonly instantiationService;
+    private readonly workingCopyFileService;
+    constructor(instantiationService: IInstantiationService, workingCopyFileService: IWorkingCopyFileService);
+    private registerSaveParticipants;
+}