@codingame/monaco-vscode-api 1.85.1 → 1.85.2

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -1,402 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { TextFileEditorModel } from './textFileEditorModel.js';
-import { Disposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { TextFileSaveParticipant } from './textFileSaveParticipant.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IWorkingCopyFileService } from '../../workingCopy/common/workingCopyFileService.js';
-import { joinPath, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { createTextBufferFactoryFromSnapshot } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
-    get models() {
-        return [...( this.mapResourceToModel.values())];
-    }
-    constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.fileService = fileService;
-        this.notificationService = notificationService;
-        this.workingCopyFileService = workingCopyFileService;
-        this.uriIdentityService = uriIdentityService;
-        this._onDidCreate = this._register(( new Emitter()));
-        this.onDidCreate = this._onDidCreate.event;
-        this._onDidResolve = this._register(( new Emitter()));
-        this.onDidResolve = this._onDidResolve.event;
-        this._onDidRemove = this._register(( new Emitter()));
-        this.onDidRemove = this._onDidRemove.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
-        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeOrphaned = this._register(( new Emitter()));
-        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidSaveError = this._register(( new Emitter()));
-        this.onDidSaveError = this._onDidSaveError.event;
-        this._onDidSave = this._register(( new Emitter()));
-        this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( new Emitter()));
-        this.onDidRevert = this._onDidRevert.event;
-        this._onDidChangeEncoding = this._register(( new Emitter()));
-        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this.mapResourceToModel = ( new ResourceMap());
-        this.mapResourceToModelListeners = ( new ResourceMap());
-        this.mapResourceToDisposeListener = ( new ResourceMap());
-        this.mapResourceToPendingModelResolvers = ( new ResourceMap());
-        this.modelResolveQueue = this._register(( new ResourceQueue()));
-        this.saveErrorHandler = (() => {
-            const notificationService = this.notificationService;
-            return {
-                onSaveError(error, model) {
-                    notificationService.error(( localizeWithPath(
-                        'vs/workbench/services/textfile/common/textFileEditorModelManager',
-                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
-                        "Failed to save '{0}': {1}",
-                        model.name,
-                        toErrorMessage(error, false)
-                    )));
-                }
-            };
-        })();
-        this.mapCorrelationIdToModelsToRestore = ( new Map());
-        this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
-        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
-    }
-    onDidFilesChange(e) {
-        for (const model of this.models) {
-            if (model.isDirty()) {
-                continue;
-            }
-            if (e.contains(model.resource, 0 , 1 )) {
-                this.queueModelReload(model);
-            }
-        }
-    }
-    onDidChangeFileSystemProviderCapabilities(e) {
-        this.queueModelReloads(e.scheme);
-    }
-    onDidChangeFileSystemProviderRegistrations(e) {
-        if (!e.added) {
-            return;
-        }
-        this.queueModelReloads(e.scheme);
-    }
-    queueModelReloads(scheme) {
-        for (const model of this.models) {
-            if (model.isDirty()) {
-                continue;
-            }
-            if (scheme === model.resource.scheme) {
-                this.queueModelReload(model);
-            }
-        }
-    }
-    queueModelReload(model) {
-        const queue = this.modelResolveQueue.queueFor(model.resource);
-        if (queue.size <= 1) {
-            queue.queue(async () => {
-                try {
-                    await this.reload(model);
-                }
-                catch (error) {
-                    onUnexpectedError(error);
-                }
-            });
-        }
-    }
-    onWillRunWorkingCopyFileOperation(e) {
-        if (e.operation === 2  || e.operation === 3 ) {
-            const modelsToRestore = [];
-            for (const { source, target } of e.files) {
-                if (source) {
-                    if (this.uriIdentityService.extUri.isEqual(source, target)) {
-                        continue;
-                    }
-                    const sourceModels = [];
-                    for (const model of this.models) {
-                        if (this.uriIdentityService.extUri.isEqualOrParent(model.resource, source)) {
-                            sourceModels.push(model);
-                        }
-                    }
-                    for (const sourceModel of sourceModels) {
-                        const sourceModelResource = sourceModel.resource;
-                        let targetModelResource;
-                        if (this.uriIdentityService.extUri.isEqual(sourceModelResource, source)) {
-                            targetModelResource = target;
-                        }
-                        else {
-                            targetModelResource = joinPath(target, sourceModelResource.path.substr(source.path.length + 1));
-                        }
-                        modelsToRestore.push({
-                            source: sourceModelResource,
-                            target: targetModelResource,
-                            languageId: sourceModel.getLanguageId(),
-                            encoding: sourceModel.getEncoding(),
-                            snapshot: sourceModel.isDirty() ? sourceModel.createSnapshot() : undefined
-                        });
-                    }
-                }
-            }
-            this.mapCorrelationIdToModelsToRestore.set(e.correlationId, modelsToRestore);
-        }
-    }
-    onDidFailWorkingCopyFileOperation(e) {
-        if (((e.operation === 2  || e.operation === 3) )) {
-            const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
-            if (modelsToRestore) {
-                this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                modelsToRestore.forEach(model => {
-                    if (model.snapshot) {
-                        this.get(model.source)?.setDirty(true);
-                    }
-                });
-            }
-        }
-    }
-    onDidRunWorkingCopyFileOperation(e) {
-        switch (e.operation) {
-            case 0 :
-                e.waitUntil((async () => {
-                    for (const { target } of e.files) {
-                        const model = this.get(target);
-                        if (model && !model.isDisposed()) {
-                            await model.revert();
-                        }
-                    }
-                })());
-                break;
-            case 2 :
-            case 3 :
-                e.waitUntil((async () => {
-                    const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
-                    if (modelsToRestore) {
-                        this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                        await Promises.settled(( modelsToRestore.map(async (modelToRestore) => {
-                            const restoredModel = await this.resolve(modelToRestore.target, {
-                                reload: { async: false },
-                                contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
-                                encoding: modelToRestore.encoding
-                            });
-                            if (modelToRestore.languageId &&
-                                modelToRestore.languageId !== PLAINTEXT_LANGUAGE_ID &&
-                                restoredModel.getLanguageId() === PLAINTEXT_LANGUAGE_ID &&
-                                extname(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
-                                restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
-                            }
-                        })));
-                    }
-                })());
-                break;
-        }
-    }
-    get(resource) {
-        return this.mapResourceToModel.get(resource);
-    }
-    has(resource) {
-        return ( this.mapResourceToModel.has(resource));
-    }
-    async reload(model) {
-        await this.joinPendingResolves(model.resource);
-        if (model.isDirty() || model.isDisposed() || !( this.has(model.resource))) {
-            return;
-        }
-        await this.doResolve(model, { reload: { async: false } });
-    }
-    async resolve(resource, options) {
-        const pendingResolve = this.joinPendingResolves(resource);
-        if (pendingResolve) {
-            await pendingResolve;
-        }
-        return this.doResolve(resource, options);
-    }
-    async doResolve(resourceOrModel, options) {
-        let model;
-        let resource;
-        if (URI.isUri(resourceOrModel)) {
-            resource = resourceOrModel;
-            model = this.get(resource);
-        }
-        else {
-            resource = resourceOrModel.resource;
-            model = resourceOrModel;
-        }
-        let modelResolve;
-        let didCreateModel = false;
-        if (model) {
-            if (options?.contents) {
-                modelResolve = model.resolve(options);
-            }
-            else if (options?.reload) {
-                if (options.reload.async) {
-                    modelResolve = Promise.resolve();
-                    (async () => {
-                        try {
-                            await model.resolve(options);
-                        }
-                        catch (error) {
-                            onUnexpectedError(error);
-                        }
-                    })();
-                }
-                else {
-                    modelResolve = model.resolve(options);
-                }
-            }
-            else {
-                modelResolve = Promise.resolve();
-            }
-        }
-        else {
-            didCreateModel = true;
-            const newModel = model = this.instantiationService.createInstance(TextFileEditorModel, resource, options ? options.encoding : undefined, options ? options.languageId : undefined);
-            modelResolve = model.resolve(options);
-            this.registerModel(newModel);
-        }
-        this.mapResourceToPendingModelResolvers.set(resource, modelResolve);
-        this.add(resource, model);
-        if (didCreateModel) {
-            this._onDidCreate.fire(model);
-            if (model.isDirty()) {
-                this._onDidChangeDirty.fire(model);
-            }
-        }
-        try {
-            await modelResolve;
-        }
-        catch (error) {
-            if (didCreateModel) {
-                model.dispose();
-            }
-            throw error;
-        }
-        finally {
-            this.mapResourceToPendingModelResolvers.delete(resource);
-        }
-        if (options?.languageId) {
-            model.setLanguageId(options.languageId);
-        }
-        if (didCreateModel && model.isDirty()) {
-            this._onDidChangeDirty.fire(model);
-        }
-        return model;
-    }
-    joinPendingResolves(resource) {
-        const pendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
-        if (!pendingModelResolve) {
-            return;
-        }
-        return this.doJoinPendingResolves(resource);
-    }
-    async doJoinPendingResolves(resource) {
-        let currentModelCopyResolve;
-        while (( this.mapResourceToPendingModelResolvers.has(resource))) {
-            const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
-            if (nextPendingModelResolve === currentModelCopyResolve) {
-                return;
-            }
-            currentModelCopyResolve = nextPendingModelResolve;
-            try {
-                await nextPendingModelResolve;
-            }
-            catch (error) {
-            }
-        }
-    }
-    registerModel(model) {
-        const modelListeners = ( new DisposableStore());
-        modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
-        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
-        modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
-        modelListeners.add(model.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(model)));
-        modelListeners.add(model.onDidSaveError(() => this._onDidSaveError.fire(model)));
-        modelListeners.add(model.onDidSave(e => this._onDidSave.fire({ model, ...e })));
-        modelListeners.add(model.onDidRevert(() => this._onDidRevert.fire(model)));
-        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
-        this.mapResourceToModelListeners.set(model.resource, modelListeners);
-    }
-    add(resource, model) {
-        const knownModel = this.mapResourceToModel.get(resource);
-        if (knownModel === model) {
-            return;
-        }
-        const disposeListener = this.mapResourceToDisposeListener.get(resource);
-        disposeListener?.dispose();
-        this.mapResourceToModel.set(resource, model);
-        this.mapResourceToDisposeListener.set(resource, model.onWillDispose(() => this.remove(resource)));
-    }
-    remove(resource) {
-        const removed = this.mapResourceToModel.delete(resource);
-        const disposeListener = this.mapResourceToDisposeListener.get(resource);
-        if (disposeListener) {
-            dispose(disposeListener);
-            this.mapResourceToDisposeListener.delete(resource);
-        }
-        const modelListener = this.mapResourceToModelListeners.get(resource);
-        if (modelListener) {
-            dispose(modelListener);
-            this.mapResourceToModelListeners.delete(resource);
-        }
-        if (removed) {
-            this._onDidRemove.fire(resource);
-        }
-    }
-    addSaveParticipant(participant) {
-        return this.saveParticipants.addSaveParticipant(participant);
-    }
-    runSaveParticipants(model, context, token) {
-        return this.saveParticipants.participate(model, context, token);
-    }
-    canDispose(model) {
-        if (model.isDisposed() ||
-            (!( this.mapResourceToPendingModelResolvers.has(model.resource)) && !model.isDirty())) {
-            return true;
-        }
-        return this.doCanDispose(model);
-    }
-    async doCanDispose(model) {
-        const pendingResolve = this.joinPendingResolves(model.resource);
-        if (pendingResolve) {
-            await pendingResolve;
-            return this.canDispose(model);
-        }
-        if (model.isDirty()) {
-            await Event.toPromise(model.onDidChangeDirty);
-            return this.canDispose(model);
-        }
-        return true;
-    }
-    dispose() {
-        super.dispose();
-        this.mapResourceToModel.clear();
-        this.mapResourceToPendingModelResolvers.clear();
-        dispose(( this.mapResourceToDisposeListener.values()));
-        this.mapResourceToDisposeListener.clear();
-        dispose(( this.mapResourceToModelListeners.values()));
-        this.mapResourceToModelListeners.clear();
-    }
-};
-TextFileEditorModelManager = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IFileService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IWorkingCopyFileService)),
-    ( __param(4, IUriIdentityService))
-], TextFileEditorModelManager));
-export { TextFileEditorModelManager };

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -1,62 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { insert } from 'monaco-editor/esm/vs/base/common/arrays.js';
-let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
-    constructor(progressService, logService) {
-        super();
-        this.progressService = progressService;
-        this.logService = logService;
-        this.saveParticipants = [];
-    }
-    addSaveParticipant(participant) {
-        const remove = insert(this.saveParticipants, participant);
-        return toDisposable(() => remove());
-    }
-    participate(model, context, token) {
-        const cts = ( new CancellationTokenSource(token));
-        return this.progressService.withProgress({
-            title: ( localizeWithPath(
-                'vs/workbench/services/textfile/common/textFileSaveParticipant',
-                'saveParticipants',
-                "Saving '{0}'",
-                model.name
-            )),
-            location: 15 ,
-            cancellable: true,
-            delay: model.isDirty() ? 3000 : 5000
-        }, async (progress) => {
-            model.textEditorModel?.pushStackElement();
-            for (const saveParticipant of this.saveParticipants) {
-                if (cts.token.isCancellationRequested || !model.textEditorModel ) {
-                    break;
-                }
-                try {
-                    const promise = saveParticipant.participate(model, context, progress, cts.token);
-                    await raceCancellation(promise, cts.token);
-                }
-                catch (err) {
-                    this.logService.error(err);
-                }
-            }
-            model.textEditorModel?.pushStackElement();
-        }, () => {
-            cts.cancel();
-        }).finally(() => {
-            cts.dispose();
-        });
-    }
-    dispose() {
-        this.saveParticipants.splice(0, this.saveParticipants.length);
-        super.dispose();
-    }
-};
-TextFileSaveParticipant = ( __decorate([
-    ( __param(0, IProgressService)),
-    ( __param(1, ILogService))
-], TextFileSaveParticipant));
-export { TextFileSaveParticipant };

package/vscode/src/vs/workbench/services/themes/browser/browserHostColorSchemeService.js

@@ -1,38 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { addMatchMediaChangeListener } from 'monaco-editor/esm/vs/base/browser/browser.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
-class BrowserHostColorSchemeService extends Disposable {
-    constructor() {
-        super();
-        this._onDidSchemeChangeEvent = this._register(( new Emitter()));
-        this.registerListeners();
-    }
-    registerListeners() {
-        addMatchMediaChangeListener('(prefers-color-scheme: dark)', () => {
-            this._onDidSchemeChangeEvent.fire();
-        });
-        addMatchMediaChangeListener('(forced-colors: active)', () => {
-            this._onDidSchemeChangeEvent.fire();
-        });
-    }
-    get onDidChangeColorScheme() {
-        return this._onDidSchemeChangeEvent.event;
-    }
-    get dark() {
-        if (mainWindow.matchMedia(`(prefers-color-scheme: light)`).matches) {
-            return false;
-        }
-        else if (mainWindow.matchMedia(`(prefers-color-scheme: dark)`).matches) {
-            return true;
-        }
-        return false;
-    }
-    get highContrast() {
-        if (mainWindow.matchMedia(`(forced-colors: active)`).matches) {
-            return true;
-        }
-        return false;
-    }
-}
-export { BrowserHostColorSchemeService };