@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/execute/executionEditorProgress.js

@@ -0,0 +1,70 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { throttle } from '../../../../../../base/common/decorators.js';
+import { Disposable, MutableDisposable } from '../../../../../../base/common/lifecycle.js';
+import { registerNotebookContribution } from '../../notebookEditorExtensions.js';
+import { NotebookCellExecutionState } from '../../../common/notebookCommon.js';
+import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
+import { IUserActivityService } from '../../../../../services/userActivity/common/userActivityService.js';
+let ExecutionEditorProgressController = class ExecutionEditorProgressController extends Disposable {
+    static { this.id = 'workbench.notebook.executionEditorProgress'; }
+    constructor(_notebookEditor, _notebookExecutionStateService, _userActivity) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._userActivity = _userActivity;
+        this._activityMutex = this._register(( new MutableDisposable()));
+        this._register(_notebookEditor.onDidScroll(() => this._update()));
+        this._register(_notebookExecutionStateService.onDidChangeExecution(e => {
+            if (( e.notebook.toString()) !== this._notebookEditor.textModel?.uri.toString()) {
+                return;
+            }
+            this._update();
+        }));
+        this._register(_notebookEditor.onDidChangeModel(() => this._update()));
+    }
+    _update() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const cellExecutions = this._notebookExecutionStateService.getCellExecutionsForNotebook(this._notebookEditor.textModel?.uri)
+            .filter(exe => exe.state === NotebookCellExecutionState.Executing);
+        const notebookExecution = this._notebookExecutionStateService.getExecution(this._notebookEditor.textModel?.uri);
+        const executionIsVisible = (exe) => {
+            for (const range of this._notebookEditor.visibleRanges) {
+                for (const cell of this._notebookEditor.getCellsInRange(range)) {
+                    if (cell.handle === exe.cellHandle) {
+                        const top = this._notebookEditor.getAbsoluteTopOfElement(cell);
+                        if (this._notebookEditor.scrollTop < top + 5) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        };
+        const hasAnyExecution = cellExecutions.length || notebookExecution;
+        if (hasAnyExecution && !this._activityMutex.value) {
+            this._activityMutex.value = this._userActivity.markActive();
+        }
+        else if (!hasAnyExecution && this._activityMutex.value) {
+            this._activityMutex.clear();
+        }
+        const shouldShowEditorProgressbarForCellExecutions = cellExecutions.length && !( cellExecutions.some(executionIsVisible)) && !( cellExecutions.some(e => e.isPaused));
+        const showEditorProgressBar = !!notebookExecution || shouldShowEditorProgressbarForCellExecutions;
+        if (showEditorProgressBar) {
+            this._notebookEditor.showProgress();
+        }
+        else {
+            this._notebookEditor.hideProgress();
+        }
+    }
+};
+ExecutionEditorProgressController.__decorator = ( __decorate([
+    throttle(100)
+], ExecutionEditorProgressController.prototype, "_update", null));
+ExecutionEditorProgressController = ( __decorate([
+    ( __param(1, INotebookExecutionStateService)),
+    ( __param(2, IUserActivityService))
+], ExecutionEditorProgressController));
+registerNotebookContribution(ExecutionEditorProgressController.id, ExecutionEditorProgressController);
+export { ExecutionEditorProgressController };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/media/notebookFind.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .notebookOverlay.notebook-editor.find-hide-transition,.monaco-workbench .notebookOverlay.notebook-editor.find-show-transition{overflow-y:hidden}.monaco-workbench .notebookOverlay.notebook-editor .simple-fr-find-part-wrapper .matchesCount{box-sizing:border-box;overflow:hidden;padding:0 2px;text-align:center;text-overflow:ellipsis;white-space:nowrap}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFind.js

@@ -0,0 +1,167 @@
+import './media/notebookFind.css.js';
+import { Schemas } from '../../../../../../base/common/network.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
+import { ICodeEditorService } from '../../../../../../editor/browser/services/codeEditorService.js';
+import { EditorContextKeys } from '../../../../../../editor/common/editorContextKeys.js';
+import { StartFindAction, StartFindReplaceAction, getSelectionSearchString } from '../../../../../../editor/contrib/find/browser/findController.js';
+import { localize2WithPath } from '../../../../../../nls.js';
+import { registerAction2, Action2 } from '../../../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../../../platform/contextkey/common/contextkey.js';
+import { NotebookFindContrib } from './notebookFindWidget.js';
+import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
+import { registerNotebookContribution } from '../../notebookEditorExtensions.js';
+import { CellUri } from '../../../common/notebookCommon.js';
+import { NOTEBOOK_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED, NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR } from '../../../common/notebookContextKeys.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+registerNotebookContribution(NotebookFindContrib.id, NotebookFindContrib);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.hideFind',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFind',
+                'notebookActions.hideFind',
+                'Hide Find in Notebook'
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED)),
+                primary: 9 ,
+                weight: 200
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookFindContrib.id);
+        controller.hide();
+        editor.focus();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.find',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFind',
+                'notebookActions.findInNotebook',
+                'Find in Notebook'
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.or(NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR)), ( EditorContextKeys.focus.toNegated()))),
+                primary: 36  | 2048 ,
+                weight: 200
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookFindContrib.id);
+        controller.show();
+    }
+});
+function notebookContainsTextModel(uri, textModel) {
+    if (textModel.uri.scheme === Schemas.vscodeNotebookCell) {
+        const cellUri = CellUri.parse(textModel.uri);
+        if (cellUri && isEqual(cellUri.notebook, uri)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getSearchStringOptions(editor, opts) {
+    if (opts.seedSearchStringFromSelection === 'single') {
+        const selectionSearchString = getSelectionSearchString(editor, opts.seedSearchStringFromSelection, opts.seedSearchStringFromNonEmptySelection);
+        if (selectionSearchString) {
+            return {
+                searchString: selectionSearchString,
+                selection: editor.getSelection()
+            };
+        }
+    }
+    else if (opts.seedSearchStringFromSelection === 'multiple' && !opts.updateSearchScope) {
+        const selectionSearchString = getSelectionSearchString(editor, opts.seedSearchStringFromSelection);
+        if (selectionSearchString) {
+            return {
+                searchString: selectionSearchString,
+                selection: editor.getSelection()
+            };
+        }
+    }
+    return undefined;
+}
+StartFindAction.addImplementation(100, (accessor, codeEditor, args) => {
+    const editorService = accessor.get(IEditorService);
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor) {
+        return false;
+    }
+    if (!codeEditor.hasModel()) {
+        return false;
+    }
+    if (!editor.hasEditorFocus() && !editor.hasWebviewFocus()) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const textEditor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+        if (editor.hasModel() && textEditor && textEditor.hasModel() && notebookContainsTextModel(editor.textModel.uri, textEditor.getModel())) ;
+        else {
+            return false;
+        }
+    }
+    const controller = editor.getContribution(NotebookFindContrib.id);
+    const searchStringOptions = getSearchStringOptions(codeEditor, {
+        forceRevealReplace: false,
+        seedSearchStringFromSelection: codeEditor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: codeEditor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: codeEditor.getOption(41 ).globalFindClipboard,
+        shouldFocus: 1 ,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: codeEditor.getOption(41 ).loop
+    });
+    let options = undefined;
+    const uri = codeEditor.getModel().uri;
+    const data = CellUri.parse(uri);
+    if (searchStringOptions?.selection && data) {
+        const cell = editor.getCellByHandle(data.handle);
+        if (cell) {
+            options = {
+                searchStringSeededFrom: { cell, range: searchStringOptions.selection },
+            };
+        }
+    }
+    controller.show(searchStringOptions?.searchString, options);
+    return true;
+});
+StartFindReplaceAction.addImplementation(100, (accessor, codeEditor, args) => {
+    const editorService = accessor.get(IEditorService);
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor) {
+        return false;
+    }
+    if (!codeEditor.hasModel()) {
+        return false;
+    }
+    const controller = editor.getContribution(NotebookFindContrib.id);
+    const searchStringOptions = getSearchStringOptions(codeEditor, {
+        forceRevealReplace: false,
+        seedSearchStringFromSelection: codeEditor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: codeEditor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: codeEditor.getOption(41 ).globalFindClipboard,
+        shouldFocus: 1 ,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: codeEditor.getOption(41 ).loop
+    });
+    if (controller) {
+        controller.replace(searchStringOptions?.searchString);
+        return true;
+    }
+    return false;
+});

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/format/formatting.js

@@ -0,0 +1,207 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localize2WithPath, localizeWithPath } from '../../../../../../nls.js';
+import { CancellationToken } from '../../../../../../base/common/cancellation.js';
+import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { registerEditorAction, EditorAction } from '../../../../../../editor/browser/editorExtensions.js';
+import { IBulkEditService, ResourceTextEdit } from '../../../../../../editor/browser/services/bulkEditService.js';
+import { EditorContextKeys } from '../../../../../../editor/common/editorContextKeys.js';
+import { IEditorWorkerService } from '../../../../../../editor/common/services/editorWorker.js';
+import { ILanguageFeaturesService } from '../../../../../../editor/common/services/languageFeatures.js';
+import { ITextModelService } from '../../../../../../editor/common/services/resolverService.js';
+import { getDocumentFormattingEditsUntilResult, formatDocumentWithSelectedProvider } from '../../../../../../editor/contrib/format/browser/format.js';
+import { registerAction2, Action2, MenuId } from '../../../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { Progress } from '../../../../../../platform/progress/common/progress.js';
+import { NOTEBOOK_ACTIONS_CATEGORY } from '../../controller/coreActions.js';
+import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_EDITABLE } from '../../../common/notebookContextKeys.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+import { INotebookExecutionService } from '../../../common/notebookExecutionService.js';
+import { NotebookSetting } from '../../../common/notebookCommon.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../../../common/contributions.js';
+import { INotebookService } from '../../../common/notebookService.js';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.format',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'format.title',
+                'Format Notebook'
+            )),
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            precondition: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_EDITABLE)),
+            keybinding: {
+                when: ( EditorContextKeys.editorTextFocus.toNegated()),
+                primary: 1024  | 512  | 36 ,
+                linux: { primary: 2048  | 1024  | 39  },
+                weight: 200
+            },
+            f1: true,
+            menu: {
+                id: MenuId.EditorContext,
+                when: ( ContextKeyExpr.and(
+                    EditorContextKeys.inCompositeEditor,
+                    EditorContextKeys.hasDocumentFormattingProvider
+                )),
+                group: '1_modification',
+                order: 1.3
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const textModelService = accessor.get(ITextModelService);
+        const editorWorkerService = accessor.get(IEditorWorkerService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const bulkEditService = accessor.get(IBulkEditService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        const notebook = editor.textModel;
+        const disposable = ( new DisposableStore());
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                const ref = await textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const formatEdits = await getDocumentFormattingEditsUntilResult(editorWorkerService, languageFeaturesService, model, model.getOptions(), CancellationToken.None);
+                const edits = [];
+                if (formatEdits) {
+                    for (const edit of formatEdits) {
+                        edits.push(( new ResourceTextEdit(model.uri, edit, model.getVersionId())));
+                    }
+                    return edits;
+                }
+                return [];
+            })));
+            await bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'label',
+                "Format Notebook"
+            )), code: 'undoredo.formatNotebook', });
+        }
+        finally {
+            disposable.dispose();
+        }
+    }
+});
+registerEditorAction(class FormatCellAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'notebook.formatCell',
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'formatCell.label',
+                "Format Cell"
+            )),
+            alias: 'Format Cell',
+            precondition: ( ContextKeyExpr.and(
+                NOTEBOOK_IS_ACTIVE_EDITOR,
+                NOTEBOOK_EDITOR_EDITABLE,
+                EditorContextKeys.inCompositeEditor,
+                EditorContextKeys.writable,
+                EditorContextKeys.hasDocumentFormattingProvider
+            )),
+            kbOpts: {
+                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus)),
+                primary: 1024  | 512  | 36 ,
+                linux: { primary: 2048  | 1024  | 39  },
+                weight: 100
+            },
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 1.301
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (editor.hasModel()) {
+            const instaService = accessor.get(IInstantiationService);
+            await instaService.invokeFunction(formatDocumentWithSelectedProvider, editor, 1 , Progress.None, CancellationToken.None, true);
+        }
+    }
+});
+let FormatOnCellExecutionParticipant = class FormatOnCellExecutionParticipant {
+    constructor(bulkEditService, languageFeaturesService, textModelService, editorWorkerService, configurationService, _notebookService) {
+        this.bulkEditService = bulkEditService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.textModelService = textModelService;
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+        this._notebookService = _notebookService;
+    }
+    async onWillExecuteCell(executions) {
+        const enabled = this.configurationService.getValue(NotebookSetting.formatOnCellExecution);
+        if (!enabled) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        try {
+            const allCellEdits = await Promise.all(( executions.map(async (cellExecution) => {
+                const nbModel = this._notebookService.getNotebookTextModel(cellExecution.notebook);
+                if (!nbModel) {
+                    return [];
+                }
+                let activeCell;
+                for (const cell of nbModel.cells) {
+                    if (cell.handle === cellExecution.cellHandle) {
+                        activeCell = cell;
+                        break;
+                    }
+                }
+                if (!activeCell) {
+                    return [];
+                }
+                const ref = await this.textModelService.createModelReference(activeCell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const formatEdits = await getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), CancellationToken.None);
+                const edits = [];
+                if (formatEdits) {
+                    edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
+                    return edits;
+                }
+                return [];
+            })));
+            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'formatCells.label',
+                "Format Cells"
+            )), code: 'undoredo.notebooks.onWillExecuteFormat', });
+        }
+        finally {
+            disposable.dispose();
+        }
+    }
+};
+FormatOnCellExecutionParticipant = ( __decorate([
+    ( __param(0, IBulkEditService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IEditorWorkerService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, INotebookService))
+], FormatOnCellExecutionParticipant));
+let CellExecutionParticipantsContribution = class CellExecutionParticipantsContribution extends Disposable {
+    constructor(instantiationService, notebookExecutionService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.notebookExecutionService = notebookExecutionService;
+        this.registerKernelExecutionParticipants();
+    }
+    registerKernelExecutionParticipants() {
+        this._register(this.notebookExecutionService.registerExecutionParticipant(this.instantiationService.createInstance(FormatOnCellExecutionParticipant)));
+    }
+};
+CellExecutionParticipantsContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookExecutionService))
+], CellExecutionParticipantsContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(CellExecutionParticipantsContribution, 3 );
+export { CellExecutionParticipantsContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/gettingStarted/notebookGettingStarted.js

@@ -0,0 +1,82 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { localize2WithPath } from '../../../../../../nls.js';
+import { Categories } from '../../../../../../platform/action/common/actionCommonCategories.js';
+import { registerAction2, Action2 } from '../../../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService, ContextKeyExpr } from '../../../../../../platform/contextkey/common/contextkey.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { IStorageService } from '../../../../../../platform/storage/common/storage.js';
+import { Extensions } from '../../../../../common/contributions.js';
+import { Memento } from '../../../../../common/memento.js';
+import { NotebookSetting } from '../../../common/notebookCommon.js';
+import { HAS_OPENED_NOTEBOOK } from '../../../common/notebookContextKeys.js';
+import { NotebookEditorInput } from '../../../common/notebookEditorInput.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+const hasOpenedNotebookKey = 'hasOpenedNotebook';
+const hasShownGettingStartedKey = 'hasShownNotebookGettingStarted';
+let NotebookGettingStarted = class NotebookGettingStarted extends Disposable {
+    constructor(_editorService, _storageService, _contextKeyService, _commandService, _configurationService) {
+        super();
+        const hasOpenedNotebook = HAS_OPENED_NOTEBOOK.bindTo(_contextKeyService);
+        const memento = ( new Memento('notebookGettingStarted2', _storageService));
+        const storedValue = memento.getMemento(0 , 0 );
+        if (storedValue[hasOpenedNotebookKey]) {
+            hasOpenedNotebook.set(true);
+        }
+        const needToShowGettingStarted = _configurationService.getValue(NotebookSetting.openGettingStarted) && !storedValue[hasShownGettingStartedKey];
+        if (!storedValue[hasOpenedNotebookKey] || needToShowGettingStarted) {
+            const onDidOpenNotebook = () => {
+                hasOpenedNotebook.set(true);
+                storedValue[hasOpenedNotebookKey] = true;
+                if (needToShowGettingStarted) {
+                    _commandService.executeCommand('workbench.action.openWalkthrough', { category: 'notebooks', step: 'notebookProfile' }, true);
+                    storedValue[hasShownGettingStartedKey] = true;
+                }
+                memento.saveMemento();
+            };
+            if (_editorService.activeEditor?.typeId === NotebookEditorInput.ID) {
+                onDidOpenNotebook();
+                return;
+            }
+            const listener = this._register(_editorService.onDidActiveEditorChange(() => {
+                if (_editorService.activeEditor?.typeId === NotebookEditorInput.ID) {
+                    listener.dispose();
+                    onDidOpenNotebook();
+                }
+            }));
+        }
+    }
+};
+NotebookGettingStarted = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IConfigurationService))
+], NotebookGettingStarted));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookGettingStarted, 3 );
+registerAction2(class NotebookClearNotebookLayoutAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.notebook.layout.gettingStarted',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/gettingStarted/notebookGettingStarted',
+                'workbench.notebook.layout.gettingStarted.label',
+                "Reset notebook getting started"
+            )),
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${NotebookSetting.openGettingStarted}`, true)),
+            category: Categories.Developer,
+        });
+    }
+    run(accessor) {
+        const storageService = accessor.get(IStorageService);
+        const memento = ( new Memento('notebookGettingStarted', storageService));
+        const storedValue = memento.getMemento(0 , 0 );
+        storedValue[hasOpenedNotebookKey] = undefined;
+        memento.saveMemento();
+    }
+});
+export { NotebookGettingStarted };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/kernelDetection/notebookKernelDetection.js

@@ -0,0 +1,81 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../../../common/contributions.js';
+import { INotebookKernelService } from '../../../common/notebookKernelService.js';
+import { INotebookLoggingService } from '../../../common/notebookLoggingService.js';
+import { IExtensionService } from '../../../../../services/extensions/common/extensions.js';
+let NotebookKernelDetection = class NotebookKernelDetection extends Disposable {
+    constructor(_notebookKernelService, _extensionService, _notebookLoggingService) {
+        super();
+        this._notebookKernelService = _notebookKernelService;
+        this._extensionService = _extensionService;
+        this._notebookLoggingService = _notebookLoggingService;
+        this._detectionMap = ( new Map());
+        this._localDisposableStore = this._register(( new DisposableStore()));
+        this._registerListeners();
+    }
+    _registerListeners() {
+        this._localDisposableStore.clear();
+        this._localDisposableStore.add(this._extensionService.onWillActivateByEvent(e => {
+            if (e.event.startsWith('onNotebook:')) {
+                if (this._extensionService.activationEventIsDone(e.event)) {
+                    return;
+                }
+                const notebookType = e.event.substring('onNotebook:'.length);
+                if (notebookType === '*') {
+                    return;
+                }
+                let shouldStartDetection = false;
+                const extensionStatus = this._extensionService.getExtensionsStatus();
+                this._extensionService.extensions.forEach(extension => {
+                    if (extensionStatus[extension.identifier.value].activationTimes) {
+                        return;
+                    }
+                    if (extension.activationEvents?.includes(e.event)) {
+                        shouldStartDetection = true;
+                    }
+                });
+                if (shouldStartDetection && !( this._detectionMap.has(notebookType))) {
+                    this._notebookLoggingService.debug('KernelDetection', `start extension activation for ${notebookType}`);
+                    const task = this._notebookKernelService.registerNotebookKernelDetectionTask({
+                        notebookType: notebookType
+                    });
+                    this._detectionMap.set(notebookType, task);
+                }
+            }
+        }));
+        let timer = null;
+        this._localDisposableStore.add(this._extensionService.onDidChangeExtensionsStatus(() => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            timer = setTimeout(() => {
+                const taskToDelete = [];
+                for (const [notebookType, task] of this._detectionMap) {
+                    if (this._extensionService.activationEventIsDone(`onNotebook:${notebookType}`)) {
+                        this._notebookLoggingService.debug('KernelDetection', `finish extension activation for ${notebookType}`);
+                        taskToDelete.push(notebookType);
+                        task.dispose();
+                    }
+                }
+                taskToDelete.forEach(notebookType => {
+                    this._detectionMap.delete(notebookType);
+                });
+            });
+        }));
+        this._localDisposableStore.add({
+            dispose: () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+            }
+        });
+    }
+};
+NotebookKernelDetection = ( __decorate([
+    ( __param(0, INotebookKernelService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, INotebookLoggingService))
+], NotebookKernelDetection));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookKernelDetection, 3 );