@codingame/monaco-vscode-notebook-service-override 4.0.0 → 4.1.0

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

@@ -1,72 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { throttle } from 'vscode/vscode/vs/base/common/decorators';
-import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
-import { NotebookCellExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
-
-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

@@ -1,6 +0,0 @@
-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

@@ -1,168 +0,0 @@
-import './media/notebookFind.css.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { StartFindAction, StartFindReplaceAction, getSelectionSearchString } from 'vscode/vscode/vs/editor/contrib/find/browser/findController';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { NotebookFindContrib } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
-import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NOTEBOOK_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED, NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-
-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

@@ -1,209 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { registerEditorAction, EditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { IBulkEditService, ResourceTextEdit } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { getDocumentFormattingEditsUntilResult, formatDocumentWithSelectedProvider } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
-import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { NOTEBOOK_ACTIONS_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_EDITABLE } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { INotebookExecutionService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
-import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-
-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

@@ -1,84 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { HAS_OPENED_NOTEBOOK } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-
-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

@@ -1,82 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-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 );