@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.2

package/vscode/src/vs/workbench/contrib/files/common/dirtyFilesIndicator.js

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { VIEWLET_ID } from './files.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { NumberBadge, IActivityService } from '../../../services/activity/common/activity.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+let DirtyFilesIndicator = class DirtyFilesIndicator extends Disposable {
+    constructor(lifecycleService, activityService, workingCopyService, filesConfigurationService) {
+        super();
+        this.lifecycleService = lifecycleService;
+        this.activityService = activityService;
+        this.workingCopyService = workingCopyService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.badgeHandle = this._register(( new MutableDisposable()));
+        this.lastKnownDirtyCount = 0;
+        this.updateActivityBadge();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.onWorkingCopyDidChangeDirty(workingCopy)));
+        this.lifecycleService.onDidShutdown(() => this.dispose());
+    }
+    onWorkingCopyDidChangeDirty(workingCopy) {
+        const gotDirty = workingCopy.isDirty();
+        if (gotDirty && !((workingCopy.capabilities & 2) ) && this.filesConfigurationService.hasShortAutoSaveDelay(workingCopy.resource)) {
+            return;
+        }
+        if (gotDirty || this.lastKnownDirtyCount > 0) {
+            this.updateActivityBadge();
+        }
+    }
+    updateActivityBadge() {
+        const dirtyCount = this.lastKnownDirtyCount = this.workingCopyService.dirtyCount;
+        if (dirtyCount > 0) {
+            this.badgeHandle.value = this.activityService.showViewContainerActivity(VIEWLET_ID, {
+                badge: ( new NumberBadge(dirtyCount, num => num === 1 ? ( localizeWithPath(
+                    'vs/workbench/contrib/files/common/dirtyFilesIndicator',
+                    'dirtyFile',
+                    "1 unsaved file"
+                )) : ( localizeWithPath(
+                    'vs/workbench/contrib/files/common/dirtyFilesIndicator',
+                    'dirtyFiles',
+                    "{0} unsaved files",
+                    dirtyCount
+                )))),
+            });
+        }
+        else {
+            this.badgeHandle.clear();
+        }
+    }
+};
+DirtyFilesIndicator = ( __decorate([
+    ( __param(0, ILifecycleService)),
+    ( __param(1, IActivityService)),
+    ( __param(2, IWorkingCopyService)),
+    ( __param(3, IFilesConfigurationService))
+], DirtyFilesIndicator));
+export { DirtyFilesIndicator };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveDocumentService.js

@@ -1,3 +1,27 @@
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 const IInteractiveDocumentService = ( createDecorator('IInteractiveDocumentService'));
-export { IInteractiveDocumentService };
+class InteractiveDocumentService extends Disposable {
+    constructor() {
+        super();
+        this._onWillAddInteractiveDocument = this._register(( new Emitter()));
+        this.onWillAddInteractiveDocument = this._onWillAddInteractiveDocument.event;
+        this._onWillRemoveInteractiveDocument = this._register(( new Emitter()));
+        this.onWillRemoveInteractiveDocument = this._onWillRemoveInteractiveDocument.event;
+    }
+    willCreateInteractiveDocument(notebookUri, inputUri, languageId) {
+        this._onWillAddInteractiveDocument.fire({
+            notebookUri,
+            inputUri,
+            languageId
+        });
+    }
+    willRemoveInteractiveDocument(notebookUri, inputUri) {
+        this._onWillRemoveInteractiveDocument.fire({
+            notebookUri,
+            inputUri
+        });
+    }
+}
+export { IInteractiveDocumentService, InteractiveDocumentService };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveEditorInput.js

@@ -0,0 +1,178 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../base/common/event.js';
+import { basename, extname } from '../../../../base/common/path.js';
+import { joinPath, isEqual } from '../../../../base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IInteractiveDocumentService } from './interactiveDocumentService.js';
+import { IInteractiveHistoryService } from './interactiveHistoryService.js';
+import { NotebookEditorInput } from '../../notebook/common/notebookEditorInput.js';
+import { INotebookService } from '../../notebook/common/notebookService.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var InteractiveEditorInput_1;
+let InteractiveEditorInput = class InteractiveEditorInput extends EditorInput {
+    static { InteractiveEditorInput_1 = this; }
+    static create(instantiationService, resource, inputResource, title, language) {
+        return instantiationService.createInstance(InteractiveEditorInput_1, resource, inputResource, title, language);
+    }
+    static { this.windowNames = {}; }
+    static setName(notebookUri, title) {
+        if (title) {
+            this.windowNames[notebookUri.path] = title;
+        }
+    }
+    static { this.ID = 'workbench.input.interactive'; }
+    get editorId() {
+        return 'interactive';
+    }
+    get typeId() {
+        return InteractiveEditorInput_1.ID;
+    }
+    get language() {
+        return this._inputModelRef?.object.textEditorModel.getLanguageId() ?? this._initLanguage;
+    }
+    get notebookEditorInput() {
+        return this._notebookEditorInput;
+    }
+    get editorInputs() {
+        return [this._notebookEditorInput];
+    }
+    get resource() {
+        return this._resource;
+    }
+    get inputResource() {
+        return this._inputResource;
+    }
+    get primary() {
+        return this._notebookEditorInput;
+    }
+    constructor(resource, inputResource, title, languageId, instantiationService, textModelService, interactiveDocumentService, historyService, _notebookService, _fileDialogService) {
+        const input = NotebookEditorInput.getOrCreate(instantiationService, resource, undefined, 'interactive', {});
+        super();
+        this._notebookService = _notebookService;
+        this._fileDialogService = _fileDialogService;
+        this._notebookEditorInput = input;
+        this._register(this._notebookEditorInput);
+        this.name = title ?? InteractiveEditorInput_1.windowNames[resource.path] ?? basename(resource.path, extname(resource.path));
+        this._initLanguage = languageId;
+        this._resource = resource;
+        this._inputResource = inputResource;
+        this._inputResolver = null;
+        this._editorModelReference = null;
+        this._inputModelRef = null;
+        this._textModelService = textModelService;
+        this._interactiveDocumentService = interactiveDocumentService;
+        this._historyService = historyService;
+        this._registerListeners();
+    }
+    _registerListeners() {
+        const oncePrimaryDisposed = Event.once(this.primary.onWillDispose);
+        this._register(oncePrimaryDisposed(() => {
+            if (!this.isDisposed()) {
+                this.dispose();
+            }
+        }));
+        this._register(this.primary.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this._register(this.primary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+        this._register(this.primary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+    }
+    get capabilities() {
+        return 4
+            | 2
+            | 1024
+            | 512 ;
+    }
+    async _resolveEditorModel() {
+        if (!this._editorModelReference) {
+            this._editorModelReference = await this._notebookEditorInput.resolve();
+        }
+        return this._editorModelReference;
+    }
+    async resolve() {
+        if (this._editorModelReference) {
+            return this._editorModelReference;
+        }
+        if (this._inputResolver) {
+            return this._inputResolver;
+        }
+        this._inputResolver = this._resolveEditorModel();
+        return this._inputResolver;
+    }
+    async resolveInput(language) {
+        if (this._inputModelRef) {
+            return this._inputModelRef.object.textEditorModel;
+        }
+        const resolvedLanguage = language ?? this._initLanguage ?? PLAINTEXT_LANGUAGE_ID;
+        this._interactiveDocumentService.willCreateInteractiveDocument(this.resource, this.inputResource, resolvedLanguage);
+        this._inputModelRef = await this._textModelService.createModelReference(this.inputResource);
+        return this._inputModelRef.object.textEditorModel;
+    }
+    async save(group, options) {
+        if (this._editorModelReference) {
+            if (this.hasCapability(4 )) {
+                return this.saveAs(group, options);
+            }
+            else {
+                await this._editorModelReference.save(options);
+            }
+            return this;
+        }
+        return undefined;
+    }
+    async saveAs(group, options) {
+        if (!this._editorModelReference) {
+            return undefined;
+        }
+        const provider = this._notebookService.getContributedNotebookType('interactive');
+        if (!provider) {
+            return undefined;
+        }
+        const filename = this.getName() + '.ipynb';
+        const pathCandidate = joinPath(await this._fileDialogService.defaultFilePath(), filename);
+        const target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
+        if (!target) {
+            return undefined;
+        }
+        return await this._editorModelReference.saveAs(target);
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof InteractiveEditorInput_1) {
+            return isEqual(this.resource, otherInput.resource) && isEqual(this.inputResource, otherInput.inputResource);
+        }
+        return false;
+    }
+    getName() {
+        return this.name;
+    }
+    isModified() {
+        return this._editorModelReference?.isModified() ?? false;
+    }
+    dispose() {
+        this._editorModelReference?.revert({ soft: true });
+        this._notebookEditorInput?.dispose();
+        this._editorModelReference?.dispose();
+        this._editorModelReference = null;
+        this._interactiveDocumentService.willRemoveInteractiveDocument(this.resource, this.inputResource);
+        this._inputModelRef?.dispose();
+        this._inputModelRef = null;
+        super.dispose();
+    }
+    get historyService() {
+        return this._historyService;
+    }
+};
+InteractiveEditorInput = InteractiveEditorInput_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ITextModelService)),
+    ( __param(6, IInteractiveDocumentService)),
+    ( __param(7, IInteractiveHistoryService)),
+    ( __param(8, INotebookService)),
+    ( __param(9, IFileDialogService))
+], InteractiveEditorInput));
+export { InteractiveEditorInput };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveHistoryService.js

@@ -0,0 +1,49 @@
+import { HistoryNavigator2 } from '../../../../base/common/history.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+const IInteractiveHistoryService = ( createDecorator('IInteractiveHistoryService'));
+class InteractiveHistoryService extends Disposable {
+    constructor() {
+        super();
+        this._history = ( new ResourceMap());
+    }
+    addToHistory(uri, value) {
+        if (!( this._history.has(uri))) {
+            this._history.set(uri, ( new HistoryNavigator2([value], 50)));
+            return;
+        }
+        const history = this._history.get(uri);
+        history.resetCursor();
+        if (history?.current() !== value) {
+            history?.add(value);
+        }
+    }
+    getPreviousValue(uri) {
+        const history = this._history.get(uri);
+        return history?.previous() ?? null;
+    }
+    getNextValue(uri) {
+        const history = this._history.get(uri);
+        return history?.next() ?? null;
+    }
+    replaceLast(uri, value) {
+        if (!( this._history.has(uri))) {
+            this._history.set(uri, ( new HistoryNavigator2([value], 50)));
+            return;
+        }
+        else {
+            const history = this._history.get(uri);
+            if (history?.current() !== value) {
+                history?.replaceLast(value);
+            }
+        }
+    }
+    clearHistory(uri) {
+        this._history.delete(uri);
+    }
+    has(uri) {
+        return ( this._history.has(uri)) ? true : false;
+    }
+}
+export { IInteractiveHistoryService, InteractiveHistoryService };