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

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionStateServiceImpl.js

@@ -1,509 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { AccessibilitySignal, IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { CellUri, NotebookCellExecutionState, NotebookExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookExecutionService, CellExecutionUpdateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
-import { NotebookExecutionType, INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-
-let NotebookExecutionStateService = class NotebookExecutionStateService extends Disposable {
-    constructor(_instantiationService, _logService, _notebookService, _accessibilitySignalService) {
-        super();
-        this._instantiationService = _instantiationService;
-        this._logService = _logService;
-        this._notebookService = _notebookService;
-        this._accessibilitySignalService = _accessibilitySignalService;
-        this._executions = ( new ResourceMap());
-        this._notebookExecutions = ( new ResourceMap());
-        this._notebookListeners = ( new ResourceMap());
-        this._cellListeners = ( new ResourceMap());
-        this._lastFailedCells = ( new ResourceMap());
-        this._onDidChangeExecution = this._register(( new Emitter()));
-        this.onDidChangeExecution = this._onDidChangeExecution.event;
-        this._onDidChangeLastRunFailState = this._register(( new Emitter()));
-        this.onDidChangeLastRunFailState = this._onDidChangeLastRunFailState.event;
-    }
-    getLastFailedCellForNotebook(notebook) {
-        const failedCell = this._lastFailedCells.get(notebook);
-        return failedCell?.visible ? failedCell.cellHandle : undefined;
-    }
-    forceCancelNotebookExecutions(notebookUri) {
-        const notebookCellExecutions = this._executions.get(notebookUri);
-        if (notebookCellExecutions) {
-            for (const exe of ( notebookCellExecutions.values())) {
-                this._onCellExecutionDidComplete(notebookUri, exe.cellHandle, exe);
-            }
-        }
-        if (( this._notebookExecutions.has(notebookUri))) {
-            this._onExecutionDidComplete(notebookUri);
-        }
-    }
-    getCellExecution(cellUri) {
-        const parsed = CellUri.parse(cellUri);
-        if (!parsed) {
-            throw new Error(`Not a cell URI: ${cellUri}`);
-        }
-        const exeMap = this._executions.get(parsed.notebook);
-        if (exeMap) {
-            return exeMap.get(parsed.handle);
-        }
-        return undefined;
-    }
-    getExecution(notebook) {
-        return this._notebookExecutions.get(notebook)?.[0];
-    }
-    getCellExecutionsForNotebook(notebook) {
-        const exeMap = this._executions.get(notebook);
-        return exeMap ? Array.from(( exeMap.values())) : [];
-    }
-    getCellExecutionsByHandleForNotebook(notebook) {
-        const exeMap = this._executions.get(notebook);
-        return exeMap ? ( new Map(exeMap.entries())) : undefined;
-    }
-    _onCellExecutionDidChange(notebookUri, cellHandle, exe) {
-        this._onDidChangeExecution.fire(( new NotebookCellExecutionEvent(notebookUri, cellHandle, exe)));
-    }
-    _onCellExecutionDidComplete(notebookUri, cellHandle, exe, lastRunSuccess) {
-        const notebookExecutions = this._executions.get(notebookUri);
-        if (!notebookExecutions) {
-            this._logService.debug(`NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`);
-            return;
-        }
-        exe.dispose();
-        const cellUri = CellUri.generate(notebookUri, cellHandle);
-        this._cellListeners.get(cellUri)?.dispose();
-        this._cellListeners.delete(cellUri);
-        notebookExecutions.delete(cellHandle);
-        if (notebookExecutions.size === 0) {
-            this._executions.delete(notebookUri);
-            this._notebookListeners.get(notebookUri)?.dispose();
-            this._notebookListeners.delete(notebookUri);
-        }
-        if (lastRunSuccess !== undefined) {
-            if (lastRunSuccess) {
-                if (this._executions.size === 0) {
-                    this._accessibilitySignalService.playSignal(AccessibilitySignal.notebookCellCompleted);
-                }
-                this._clearLastFailedCell(notebookUri);
-            }
-            else {
-                this._accessibilitySignalService.playSignal(AccessibilitySignal.notebookCellFailed);
-                this._setLastFailedCell(notebookUri, cellHandle);
-            }
-        }
-        this._onDidChangeExecution.fire(( new NotebookCellExecutionEvent(notebookUri, cellHandle)));
-    }
-    _onExecutionDidChange(notebookUri, exe) {
-        this._onDidChangeExecution.fire(( new NotebookExecutionEvent(notebookUri, exe)));
-    }
-    _onExecutionDidComplete(notebookUri) {
-        const disposables = this._notebookExecutions.get(notebookUri);
-        if (!Array.isArray(disposables)) {
-            this._logService.debug(`NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`);
-            return;
-        }
-        this._notebookExecutions.delete(notebookUri);
-        this._onDidChangeExecution.fire(( new NotebookExecutionEvent(notebookUri)));
-        disposables.forEach(d => d.dispose());
-    }
-    createCellExecution(notebookUri, cellHandle) {
-        const notebook = this._notebookService.getNotebookTextModel(notebookUri);
-        if (!notebook) {
-            throw new Error(`Notebook not found: ${notebookUri.toString()}`);
-        }
-        let notebookExecutionMap = this._executions.get(notebookUri);
-        if (!notebookExecutionMap) {
-            const listeners = this._instantiationService.createInstance(NotebookExecutionListeners, notebookUri);
-            this._notebookListeners.set(notebookUri, listeners);
-            notebookExecutionMap = ( new Map());
-            this._executions.set(notebookUri, notebookExecutionMap);
-        }
-        let exe = notebookExecutionMap.get(cellHandle);
-        if (!exe) {
-            exe = this._createNotebookCellExecution(notebook, cellHandle);
-            notebookExecutionMap.set(cellHandle, exe);
-            exe.initialize();
-            this._onDidChangeExecution.fire(( new NotebookCellExecutionEvent(notebookUri, cellHandle, exe)));
-        }
-        return exe;
-    }
-    createExecution(notebookUri) {
-        const notebook = this._notebookService.getNotebookTextModel(notebookUri);
-        if (!notebook) {
-            throw new Error(`Notebook not found: ${notebookUri.toString()}`);
-        }
-        if (!( this._notebookListeners.has(notebookUri))) {
-            const listeners = this._instantiationService.createInstance(NotebookExecutionListeners, notebookUri);
-            this._notebookListeners.set(notebookUri, listeners);
-        }
-        let info = this._notebookExecutions.get(notebookUri);
-        if (!info) {
-            info = this._createNotebookExecution(notebook);
-            this._notebookExecutions.set(notebookUri, info);
-            this._onDidChangeExecution.fire(( new NotebookExecutionEvent(notebookUri, info[0])));
-        }
-        return info[0];
-    }
-    _createNotebookCellExecution(notebook, cellHandle) {
-        const notebookUri = notebook.uri;
-        const exe = this._instantiationService.createInstance(CellExecution, cellHandle, notebook);
-        const disposable = combinedDisposable(exe.onDidUpdate(() => this._onCellExecutionDidChange(notebookUri, cellHandle, exe)), exe.onDidComplete(lastRunSuccess => this._onCellExecutionDidComplete(notebookUri, cellHandle, exe, lastRunSuccess)));
-        this._cellListeners.set(CellUri.generate(notebookUri, cellHandle), disposable);
-        return exe;
-    }
-    _createNotebookExecution(notebook) {
-        const notebookUri = notebook.uri;
-        const exe = this._instantiationService.createInstance(NotebookExecution, notebook);
-        const disposable = combinedDisposable(exe.onDidUpdate(() => this._onExecutionDidChange(notebookUri, exe)), exe.onDidComplete(() => this._onExecutionDidComplete(notebookUri)));
-        return [exe, disposable];
-    }
-    _setLastFailedCell(notebookURI, cellHandle) {
-        const prevLastFailedCellInfo = this._lastFailedCells.get(notebookURI);
-        const notebook = this._notebookService.getNotebookTextModel(notebookURI);
-        if (!notebook) {
-            return;
-        }
-        const newLastFailedCellInfo = {
-            cellHandle: cellHandle,
-            disposable: prevLastFailedCellInfo ? prevLastFailedCellInfo.disposable : this._getFailedCellListener(notebook),
-            visible: true
-        };
-        this._lastFailedCells.set(notebookURI, newLastFailedCellInfo);
-        this._onDidChangeLastRunFailState.fire({ visible: true, notebook: notebookURI });
-    }
-    _setLastFailedCellVisibility(notebookURI, visible) {
-        const lastFailedCellInfo = this._lastFailedCells.get(notebookURI);
-        if (lastFailedCellInfo) {
-            this._lastFailedCells.set(notebookURI, {
-                cellHandle: lastFailedCellInfo.cellHandle,
-                disposable: lastFailedCellInfo.disposable,
-                visible: visible,
-            });
-        }
-        this._onDidChangeLastRunFailState.fire({ visible: visible, notebook: notebookURI });
-    }
-    _clearLastFailedCell(notebookURI) {
-        const lastFailedCellInfo = this._lastFailedCells.get(notebookURI);
-        if (lastFailedCellInfo) {
-            lastFailedCellInfo.disposable?.dispose();
-            this._lastFailedCells.delete(notebookURI);
-        }
-        this._onDidChangeLastRunFailState.fire({ visible: false, notebook: notebookURI });
-    }
-    _getFailedCellListener(notebook) {
-        return notebook.onWillAddRemoveCells((e) => {
-            const lastFailedCell = this._lastFailedCells.get(notebook.uri)?.cellHandle;
-            if (lastFailedCell !== undefined) {
-                const lastFailedCellPos = notebook.cells.findIndex(c => c.handle === lastFailedCell);
-                e.rawEvent.changes.forEach(([start, deleteCount, addedCells]) => {
-                    if (deleteCount) {
-                        if (lastFailedCellPos >= start && lastFailedCellPos < start + deleteCount) {
-                            this._setLastFailedCellVisibility(notebook.uri, false);
-                        }
-                    }
-                    if (( addedCells.some(cell => cell.handle === lastFailedCell))) {
-                        this._setLastFailedCellVisibility(notebook.uri, true);
-                    }
-                });
-            }
-        });
-    }
-    dispose() {
-        super.dispose();
-        this._executions.forEach(executionMap => {
-            executionMap.forEach(execution => execution.dispose());
-            executionMap.clear();
-        });
-        this._executions.clear();
-        this._notebookExecutions.forEach(disposables => {
-            disposables.forEach(d => d.dispose());
-        });
-        this._notebookExecutions.clear();
-        this._cellListeners.forEach(disposable => disposable.dispose());
-        this._notebookListeners.forEach(disposable => disposable.dispose());
-        this._lastFailedCells.forEach(elem => elem.disposable.dispose());
-    }
-};
-NotebookExecutionStateService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, ILogService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, IAccessibilitySignalService))
-], NotebookExecutionStateService));
-class NotebookCellExecutionEvent {
-    constructor(notebook, cellHandle, changed) {
-        this.notebook = notebook;
-        this.cellHandle = cellHandle;
-        this.changed = changed;
-        this.type = NotebookExecutionType.cell;
-    }
-    affectsCell(cell) {
-        const parsedUri = CellUri.parse(cell);
-        return !!parsedUri && isEqual(this.notebook, parsedUri.notebook) && this.cellHandle === parsedUri.handle;
-    }
-    affectsNotebook(notebook) {
-        return isEqual(this.notebook, notebook);
-    }
-}
-class NotebookExecutionEvent {
-    constructor(notebook, changed) {
-        this.notebook = notebook;
-        this.changed = changed;
-        this.type = NotebookExecutionType.notebook;
-    }
-    affectsNotebook(notebook) {
-        return isEqual(this.notebook, notebook);
-    }
-}
-let NotebookExecutionListeners = class NotebookExecutionListeners extends Disposable {
-    constructor(notebook, _notebookService, _notebookKernelService, _notebookExecutionService, _notebookExecutionStateService, _logService) {
-        super();
-        this._notebookService = _notebookService;
-        this._notebookKernelService = _notebookKernelService;
-        this._notebookExecutionService = _notebookExecutionService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this._logService = _logService;
-        this._logService.debug(`NotebookExecution#ctor ${( notebook.toString())}`);
-        const notebookModel = this._notebookService.getNotebookTextModel(notebook);
-        if (!notebookModel) {
-            throw new Error('Notebook not found: ' + notebook);
-        }
-        this._notebookModel = notebookModel;
-        this._register(this._notebookModel.onWillAddRemoveCells(e => this.onWillAddRemoveCells(e)));
-        this._register(this._notebookModel.onWillDispose(() => this.onWillDisposeDocument()));
-    }
-    cancelAll() {
-        this._logService.debug(`NotebookExecutionListeners#cancelAll`);
-        const exes = this._notebookExecutionStateService.getCellExecutionsForNotebook(this._notebookModel.uri);
-        this._notebookExecutionService.cancelNotebookCellHandles(this._notebookModel, ( exes.map(exe => exe.cellHandle)));
-    }
-    onWillDisposeDocument() {
-        this._logService.debug(`NotebookExecution#onWillDisposeDocument`);
-        this.cancelAll();
-    }
-    onWillAddRemoveCells(e) {
-        const notebookExes = this._notebookExecutionStateService.getCellExecutionsByHandleForNotebook(this._notebookModel.uri);
-        const executingDeletedHandles = ( new Set());
-        const pendingDeletedHandles = ( new Set());
-        if (notebookExes) {
-            e.rawEvent.changes.forEach(([start, deleteCount]) => {
-                if (deleteCount) {
-                    const deletedHandles = ( this._notebookModel.cells.slice(start, start + deleteCount).map(c => c.handle));
-                    deletedHandles.forEach(h => {
-                        const exe = notebookExes.get(h);
-                        if (exe?.state === NotebookCellExecutionState.Executing) {
-                            executingDeletedHandles.add(h);
-                        }
-                        else if (exe) {
-                            pendingDeletedHandles.add(h);
-                        }
-                    });
-                }
-            });
-        }
-        if (executingDeletedHandles.size || pendingDeletedHandles.size) {
-            const kernel = this._notebookKernelService.getSelectedOrSuggestedKernel(this._notebookModel);
-            if (kernel) {
-                const implementsInterrupt = kernel.implementsInterrupt;
-                const handlesToCancel = implementsInterrupt ? [...executingDeletedHandles] : [...executingDeletedHandles, ...pendingDeletedHandles];
-                this._logService.debug(`NotebookExecution#onWillAddRemoveCells, ${JSON.stringify([...handlesToCancel])}`);
-                if (handlesToCancel.length) {
-                    kernel.cancelNotebookCellExecution(this._notebookModel.uri, handlesToCancel);
-                }
-            }
-        }
-    }
-};
-NotebookExecutionListeners = ( __decorate([
-    ( __param(1, INotebookService)),
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, INotebookExecutionService)),
-    ( __param(4, INotebookExecutionStateService)),
-    ( __param(5, ILogService))
-], NotebookExecutionListeners));
-function updateToEdit(update, cellHandle) {
-    if (update.editType === CellExecutionUpdateType.Output) {
-        return {
-            editType: 2 ,
-            handle: update.cellHandle,
-            append: update.append,
-            outputs: update.outputs,
-        };
-    }
-    else if (update.editType === CellExecutionUpdateType.OutputItems) {
-        return {
-            editType: 7 ,
-            items: update.items,
-            append: update.append,
-            outputId: update.outputId
-        };
-    }
-    else if (update.editType === CellExecutionUpdateType.ExecutionState) {
-        const newInternalMetadata = {};
-        if (typeof update.executionOrder !== 'undefined') {
-            newInternalMetadata.executionOrder = update.executionOrder;
-        }
-        if (typeof update.runStartTime !== 'undefined') {
-            newInternalMetadata.runStartTime = update.runStartTime;
-        }
-        return {
-            editType: 9 ,
-            handle: cellHandle,
-            internalMetadata: newInternalMetadata
-        };
-    }
-    throw new Error('Unknown cell update type');
-}
-let CellExecution = class CellExecution extends Disposable {
-    get state() {
-        return this._state;
-    }
-    get notebook() {
-        return this._notebookModel.uri;
-    }
-    get didPause() {
-        return this._didPause;
-    }
-    get isPaused() {
-        return this._isPaused;
-    }
-    constructor(cellHandle, _notebookModel, _logService) {
-        super();
-        this.cellHandle = cellHandle;
-        this._notebookModel = _notebookModel;
-        this._logService = _logService;
-        this._onDidUpdate = this._register(( new Emitter()));
-        this.onDidUpdate = this._onDidUpdate.event;
-        this._onDidComplete = this._register(( new Emitter()));
-        this.onDidComplete = this._onDidComplete.event;
-        this._state = NotebookCellExecutionState.Unconfirmed;
-        this._didPause = false;
-        this._isPaused = false;
-        this._logService.debug(`CellExecution#ctor ${this.getCellLog()}`);
-    }
-    initialize() {
-        const startExecuteEdit = {
-            editType: 9 ,
-            handle: this.cellHandle,
-            internalMetadata: {
-                executionId: generateUuid(),
-                runStartTime: null,
-                runEndTime: null,
-                lastRunSuccess: null,
-                executionOrder: null,
-                renderDuration: null,
-            }
-        };
-        this._applyExecutionEdits([startExecuteEdit]);
-    }
-    getCellLog() {
-        return `${( this._notebookModel.uri.toString())}, ${this.cellHandle}`;
-    }
-    logUpdates(updates) {
-        const updateTypes = ( updates.map(u => CellExecutionUpdateType[u.editType])).join(', ');
-        this._logService.debug(`CellExecution#updateExecution ${this.getCellLog()}, [${updateTypes}]`);
-    }
-    confirm() {
-        this._logService.debug(`CellExecution#confirm ${this.getCellLog()}`);
-        this._state = NotebookCellExecutionState.Pending;
-        this._onDidUpdate.fire();
-    }
-    update(updates) {
-        this.logUpdates(updates);
-        if (( updates.some(u => u.editType === CellExecutionUpdateType.ExecutionState))) {
-            this._state = NotebookCellExecutionState.Executing;
-        }
-        if (!this._didPause && ( updates.some(u => u.editType === CellExecutionUpdateType.ExecutionState && u.didPause))) {
-            this._didPause = true;
-        }
-        const lastIsPausedUpdate = [...updates].reverse().find(u => u.editType === CellExecutionUpdateType.ExecutionState && typeof u.isPaused === 'boolean');
-        if (lastIsPausedUpdate) {
-            this._isPaused = lastIsPausedUpdate.isPaused;
-        }
-        const cellModel = this._notebookModel.cells.find(c => c.handle === this.cellHandle);
-        if (!cellModel) {
-            this._logService.debug(`CellExecution#update, updating cell not in notebook: ${( this._notebookModel.uri.toString())}, ${this.cellHandle}`);
-        }
-        else {
-            const edits = ( updates.map(update => updateToEdit(update, this.cellHandle)));
-            this._applyExecutionEdits(edits);
-        }
-        if (( updates.some(u => u.editType === CellExecutionUpdateType.ExecutionState))) {
-            this._onDidUpdate.fire();
-        }
-    }
-    complete(completionData) {
-        const cellModel = this._notebookModel.cells.find(c => c.handle === this.cellHandle);
-        if (!cellModel) {
-            this._logService.debug(`CellExecution#complete, completing cell not in notebook: ${( this._notebookModel.uri.toString())}, ${this.cellHandle}`);
-        }
-        else {
-            const edit = {
-                editType: 9 ,
-                handle: this.cellHandle,
-                internalMetadata: {
-                    lastRunSuccess: completionData.lastRunSuccess,
-                    runStartTime: this._didPause ? null : cellModel.internalMetadata.runStartTime,
-                    runEndTime: this._didPause ? null : completionData.runEndTime,
-                }
-            };
-            this._applyExecutionEdits([edit]);
-        }
-        this._onDidComplete.fire(completionData.lastRunSuccess);
-    }
-    _applyExecutionEdits(edits) {
-        this._notebookModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
-    }
-};
-CellExecution = ( __decorate([
-    ( __param(2, ILogService))
-], CellExecution));
-let NotebookExecution = class NotebookExecution extends Disposable {
-    get state() {
-        return this._state;
-    }
-    get notebook() {
-        return this._notebookModel.uri;
-    }
-    constructor(_notebookModel, _logService) {
-        super();
-        this._notebookModel = _notebookModel;
-        this._logService = _logService;
-        this._onDidUpdate = this._register(( new Emitter()));
-        this.onDidUpdate = this._onDidUpdate.event;
-        this._onDidComplete = this._register(( new Emitter()));
-        this.onDidComplete = this._onDidComplete.event;
-        this._state = NotebookExecutionState.Unconfirmed;
-        this._logService.debug(`NotebookExecution#ctor`);
-    }
-    debug(message) {
-        this._logService.debug(`${message} ${( this._notebookModel.uri.toString())}`);
-    }
-    confirm() {
-        this.debug(`Execution#confirm`);
-        this._state = NotebookExecutionState.Pending;
-        this._onDidUpdate.fire();
-    }
-    begin() {
-        this.debug(`Execution#begin`);
-        this._state = NotebookExecutionState.Executing;
-        this._onDidUpdate.fire();
-    }
-    complete() {
-        this.debug(`Execution#begin`);
-        this._state = NotebookExecutionState.Unconfirmed;
-        this._onDidComplete.fire();
-    }
-};
-NotebookExecution = ( __decorate([
-    ( __param(1, ILogService))
-], NotebookExecution));
-
-export { NotebookExecutionStateService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl.js

@@ -1,130 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { LinkedMap } from 'vscode/vscode/vs/base/common/map';
-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 { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { INotebookKernelHistoryService, INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
-
-var NotebookKernelHistoryService_1;
-const MAX_KERNELS_IN_HISTORY = 5;
-let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Disposable {
-    static { NotebookKernelHistoryService_1 = this; }
-    static { this.STORAGE_KEY = 'notebook.kernelHistory'; }
-    constructor(_storageService, _notebookKernelService, _notebookLoggingService) {
-        super();
-        this._storageService = _storageService;
-        this._notebookKernelService = _notebookKernelService;
-        this._notebookLoggingService = _notebookLoggingService;
-        this._mostRecentKernelsMap = {};
-        this._loadState();
-        this._register(this._storageService.onWillSaveState(() => this._saveState()));
-        this._register(this._storageService.onDidChangeValue(1 , NotebookKernelHistoryService_1.STORAGE_KEY, this._register(( new DisposableStore())))(() => {
-            this._loadState();
-        }));
-    }
-    getKernels(notebook) {
-        const allAvailableKernels = this._notebookKernelService.getMatchingKernel(notebook);
-        const allKernels = allAvailableKernels.all;
-        const selectedKernel = allAvailableKernels.selected;
-        const suggested = allAvailableKernels.all.length === 1 ? allAvailableKernels.all[0] : undefined;
-        this._notebookLoggingService.debug('History', `getMatchingKernels: ${allAvailableKernels.all.length} kernels available for ${notebook.uri.path}. Selected: ${allAvailableKernels.selected?.label}. Suggested: ${suggested?.label}`);
-        const mostRecentKernelIds = this._mostRecentKernelsMap[notebook.viewType] ? [...( this._mostRecentKernelsMap[notebook.viewType].values())] : [];
-        const all = ( mostRecentKernelIds.map(kernelId => allKernels.find(kernel => kernel.id === kernelId))).filter(kernel => !!kernel);
-        this._notebookLoggingService.debug('History', `mru: ${mostRecentKernelIds.length} kernels in history, ${all.length} registered already.`);
-        return {
-            selected: selectedKernel ?? suggested,
-            all
-        };
-    }
-    addMostRecentKernel(kernel) {
-        const key = kernel.id;
-        const viewType = kernel.viewType;
-        const recentKeynels = this._mostRecentKernelsMap[viewType] ?? ( new LinkedMap());
-        recentKeynels.set(key, key, 1 );
-        if (recentKeynels.size > MAX_KERNELS_IN_HISTORY) {
-            const reserved = [...recentKeynels.entries()].slice(0, MAX_KERNELS_IN_HISTORY);
-            recentKeynels.fromJSON(reserved);
-        }
-        this._mostRecentKernelsMap[viewType] = recentKeynels;
-    }
-    _saveState() {
-        let notEmpty = false;
-        for (const [_, kernels] of Object.entries(this._mostRecentKernelsMap)) {
-            notEmpty = notEmpty || kernels.size > 0;
-        }
-        if (notEmpty) {
-            const serialized = this._serialize();
-            this._storageService.store(NotebookKernelHistoryService_1.STORAGE_KEY, JSON.stringify(serialized), 1 , 0 );
-        }
-        else {
-            this._storageService.remove(NotebookKernelHistoryService_1.STORAGE_KEY, 1 );
-        }
-    }
-    _loadState() {
-        const serialized = this._storageService.get(NotebookKernelHistoryService_1.STORAGE_KEY, 1 );
-        if (serialized) {
-            try {
-                this._deserialize(JSON.parse(serialized));
-            }
-            catch (e) {
-                this._mostRecentKernelsMap = {};
-            }
-        }
-        else {
-            this._mostRecentKernelsMap = {};
-        }
-    }
-    _serialize() {
-        const result = Object.create(null);
-        for (const [viewType, kernels] of Object.entries(this._mostRecentKernelsMap)) {
-            result[viewType] = {
-                entries: [...( kernels.values())]
-            };
-        }
-        return result;
-    }
-    _deserialize(serialized) {
-        this._mostRecentKernelsMap = {};
-        for (const [viewType, kernels] of Object.entries(serialized)) {
-            const linkedMap = ( new LinkedMap());
-            const mapValues = [];
-            for (const entry of kernels.entries) {
-                mapValues.push([entry, entry]);
-            }
-            linkedMap.fromJSON(mapValues);
-            this._mostRecentKernelsMap[viewType] = linkedMap;
-        }
-    }
-    _clear() {
-        this._mostRecentKernelsMap = {};
-        this._saveState();
-    }
-};
-NotebookKernelHistoryService = NotebookKernelHistoryService_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, INotebookKernelService)),
-    ( __param(2, INotebookLoggingService))
-], NotebookKernelHistoryService));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.clearNotebookKernelsMRUCache',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl',
-                'workbench.notebook.clearNotebookKernelsMRUCache',
-                "Clear Notebook Kernels MRU Cache"
-            )),
-            category: Categories.Developer,
-            f1: true
-        });
-    }
-    async run(accessor) {
-        const historyService = accessor.get(INotebookKernelHistoryService);
-        historyService._clear();
-    }
-});
-
-export { NotebookKernelHistoryService };