@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/contributedOpeners.js

@@ -0,0 +1,83 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { updateContributedOpeners } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+var ContributedExternalUriOpenersStore_1;
+let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStore extends Disposable {
+    static { ContributedExternalUriOpenersStore_1 = this; }
+    static { this.STORAGE_ID = 'externalUriOpeners'; }
+    constructor(storageService, _extensionService) {
+        super();
+        this._extensionService = _extensionService;
+        this._openers = ( new Map());
+        this._memento = ( new Memento(ContributedExternalUriOpenersStore_1.STORAGE_ID, storageService));
+        this._mementoObject = this._memento.getMemento(0 , 1 );
+        for (const [id, value] of Object.entries(this._mementoObject || {})) {
+            this.add(id, value.extensionId, { isCurrentlyRegistered: false });
+        }
+        this.invalidateOpenersOnExtensionsChanged();
+        this._register(this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged()));
+        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged()));
+    }
+    didRegisterOpener(id, extensionId) {
+        this.add(id, extensionId, {
+            isCurrentlyRegistered: true
+        });
+    }
+    add(id, extensionId, options) {
+        const existing = this._openers.get(id);
+        if (existing) {
+            existing.isCurrentlyRegistered = existing.isCurrentlyRegistered || options.isCurrentlyRegistered;
+            return;
+        }
+        const entry = {
+            extensionId,
+            isCurrentlyRegistered: options.isCurrentlyRegistered
+        };
+        this._openers.set(id, entry);
+        this._mementoObject[id] = entry;
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    delete(id) {
+        this._openers.delete(id);
+        delete this._mementoObject[id];
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    async invalidateOpenersOnExtensionsChanged() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const registeredExtensions = this._extensionService.extensions;
+        for (const [id, entry] of this._openers) {
+            const extension = registeredExtensions.find(r => r.identifier.value === entry.extensionId);
+            if (extension) {
+                if (!this._extensionService.canRemoveExtension(extension)) {
+                    if (!entry.isCurrentlyRegistered) {
+                        this.delete(id);
+                    }
+                }
+            }
+            else {
+                this.delete(id);
+            }
+        }
+    }
+    updateSchema() {
+        const ids = [];
+        const descriptions = [];
+        for (const [id, entry] of this._openers) {
+            ids.push(id);
+            descriptions.push(entry.extensionId);
+        }
+        updateContributedOpeners(ids, descriptions);
+    }
+};
+ContributedExternalUriOpenersStore = ContributedExternalUriOpenersStore_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionService))
+], ContributedExternalUriOpenersStore));
+
+export { ContributedExternalUriOpenersStore };

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

@@ -0,0 +1,179 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { joinPath, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { IInteractiveDocumentService } from 'vscode/vscode/vs/workbench/contrib/interactive/browser/interactiveDocumentService';
+import { IInteractiveHistoryService } from './interactiveHistoryService.js';
+import { NotebookEditorInput } from '../../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+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.create(instantiationService, resource, 'interactive', {});
+        super();
+        this._notebookService = _notebookService;
+        this._fileDialogService = _fileDialogService;
+        this._notebookEditorInput = input;
+        this._register(this._notebookEditorInput);
+        this.name = title ?? InteractiveEditorInput_1.windowNames[resource.path] ?? path.basename(resource.path, 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
+            | 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,5 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+const IInteractiveHistoryService = ( createDecorator('IInteractiveHistoryService'));
+
+export { IInteractiveHistoryService };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput.js

@@ -0,0 +1,144 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { assertFn } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { DEFAULT_EDITOR_ASSOCIATION, isResourceMergeEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
+import { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { TempFileMergeEditorModeFactory, WorkspaceMergeEditorModeFactory } from './mergeEditorInputModel.js';
+import { MergeEditorTelemetry } from './telemetry.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+var MergeEditorInput_1;
+let MergeEditorInput = class MergeEditorInput extends AbstractTextResourceEditorInput {
+    static { MergeEditorInput_1 = this; }
+    static { this.ID = 'mergeEditor.Input'; }
+    get useWorkingCopy() {
+        return this.configurationService.getValue('mergeEditor.useWorkingCopy') ?? false;
+    }
+    constructor(base, input1, input2, result, _instaService, editorService, textFileService, labelService, fileService, configurationService, filesConfigurationService) {
+        super(result, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
+        this.base = base;
+        this.input1 = input1;
+        this.input2 = input2;
+        this.result = result;
+        this._instaService = _instaService;
+        this.configurationService = configurationService;
+        this.closeHandler = {
+            showConfirm: () => this._inputModel?.shouldConfirmClose() ?? false,
+            confirm: async (editors) => {
+                assertFn(() => editors.every(e => e.editor instanceof MergeEditorInput_1));
+                const inputModels = ( editors.map(e => e.editor._inputModel)).filter(isDefined);
+                return await this._inputModel.confirmClose(inputModels);
+            },
+        };
+        this.mergeEditorModeFactory = this._instaService.createInstance(this.useWorkingCopy
+            ? TempFileMergeEditorModeFactory
+            : WorkspaceMergeEditorModeFactory, this._instaService.createInstance(MergeEditorTelemetry));
+    }
+    dispose() {
+        super.dispose();
+    }
+    get typeId() {
+        return MergeEditorInput_1.ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    get capabilities() {
+        let capabilities = super.capabilities | 256 ;
+        if (this.useWorkingCopy) {
+            capabilities |= 4 ;
+        }
+        return capabilities;
+    }
+    getName() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInput',
+            'name',
+            "Merging: {0}",
+            super.getName()
+        ));
+    }
+    async resolve() {
+        if (!this._inputModel) {
+            const inputModel = this._register(await this.mergeEditorModeFactory.createInputModel({
+                base: this.base,
+                input1: this.input1,
+                input2: this.input2,
+                result: this.result,
+            }));
+            this._inputModel = inputModel;
+            this._register(autorun(reader => {
+                inputModel.isDirty.read(reader);
+                this._onDidChangeDirty.fire();
+            }));
+            await this._inputModel.model.onInitialized;
+        }
+        return this._inputModel;
+    }
+    async accept() {
+        await this._inputModel?.accept();
+    }
+    async save(group, options) {
+        await this._inputModel?.save(options);
+        return undefined;
+    }
+    toUntyped() {
+        return {
+            input1: { resource: this.input1.uri, label: this.input1.title, description: this.input1.description, detail: this.input1.detail },
+            input2: { resource: this.input2.uri, label: this.input2.title, description: this.input2.description, detail: this.input2.detail },
+            base: { resource: this.base },
+            result: { resource: this.result },
+            options: {
+                override: this.typeId
+            }
+        };
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof MergeEditorInput_1) {
+            return isEqual(this.base, otherInput.base)
+                && isEqual(this.input1.uri, otherInput.input1.uri)
+                && isEqual(this.input2.uri, otherInput.input2.uri)
+                && isEqual(this.result, otherInput.result);
+        }
+        if (isResourceMergeEditorInput(otherInput)) {
+            return (this.editorId === otherInput.options?.override || otherInput.options?.override === undefined)
+                && isEqual(this.base, otherInput.base.resource)
+                && isEqual(this.input1.uri, otherInput.input1.resource)
+                && isEqual(this.input2.uri, otherInput.input2.resource)
+                && isEqual(this.result, otherInput.result.resource);
+        }
+        return false;
+    }
+    async revert(group, options) {
+        return this._inputModel?.revert(options);
+    }
+    isDirty() {
+        return this._inputModel?.isDirty.get() ?? false;
+    }
+    setLanguageId(languageId, source) {
+        this._inputModel?.model.setLanguageId(languageId, source);
+    }
+};
+MergeEditorInput = MergeEditorInput_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IFilesConfigurationService))
+], MergeEditorInput));
+
+export { MergeEditorInput };