@codingame/monaco-editor-wrapper 4.0.0-monaco-update.2 → 4.0.0-monaco-update.4

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -0,0 +1,404 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { TextFileEditorModel } from 'vscode/vscode/vs/workbench/services/textfile/common/textFileEditorModel';
+import { Disposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { TextFileSaveParticipant } from './textFileSaveParticipant.js';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { joinPath, extname } from 'vscode/vscode/vs/base/common/resources';
+import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+
+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/dist/node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -0,0 +1,64 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { insert } from 'vscode/vscode/vs/base/common/arrays';
+
+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/dist/services.d.ts

@@ -1,5 +1,6 @@
 import * as monaco from 'monaco-editor';
 import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry';
+import 'vscode/localExtensionHost';
 declare const editorOpenHandlerRegistry: EditorOpenHandlerRegistry;
 export declare function setUseGlobalPicker(useGlobalPicker?: boolean): void;
 export declare function useGlobalPicker(): boolean;

package/dist/services.js

@@ -15,9 +15,18 @@ import getEditorServiceOverride from '@codingame/monaco-vscode-editor-service-ov
 import getStorageServiceOverride from '@codingame/monaco-vscode-storage-service-override';
 import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-service-override';
 import getQuickAccessServiceOverride from '@codingame/monaco-vscode-quickaccess-service-override';
+import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
+import getWorkingCopyServiceOverride from '@codingame/monaco-vscode-working-copy-service-override';
 import { initialize as initialize$1, StandaloneServices, ILogService, LogLevel } from 'vscode/services';
 import * as monaco from 'monaco-editor';
+import { initFile } from './node_modules/@codingame/monaco-vscode-files-service-override/files.js';
+import 'vscode/vscode/vs/platform/files/common/files';
+import 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
+import 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
+import 'vscode/vscode/vs/base/browser/indexedDB';
+import './node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
 import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry.js';
+import 'vscode/localExtensionHost';
 
 const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
 let _useGlobalPicker = false;
@@ -29,6 +38,7 @@ function useGlobalPicker() {
     return _useGlobalPicker;
 }
 let services = {
+    ...getLogServiceOverride(),
     ...getExtensionServiceOverride(),
     ...getModelServiceOverride(),
     ...getDialogsServiceOverride(),
@@ -55,7 +65,8 @@ let services = {
         shouldUseGlobalPicker() {
             return useGlobalPicker();
         }
-    })
+    }),
+    ...getWorkingCopyServiceOverride()
 };
 function registerServices(newServices) {
     services = {
@@ -66,7 +77,13 @@ function registerServices(newServices) {
 async function initialize() {
     // wait a short time for the services to be registered
     await new Promise(resolve => setTimeout(resolve, 0));
-    await initialize$1(services, undefined, { workspaceProvider: { open: async () => false, workspace: { workspaceUri: monaco.Uri.file('/tmp/project') }, trusted: true } });
+    const workspaceFile = monaco.Uri.file('/workspace.code-workspace');
+    await initFile(workspaceFile, JSON.stringify({
+        folders: [{
+                path: '/tmp/project'
+            }]
+    }));
+    await initialize$1(services, undefined, { workspaceProvider: { open: async () => false, workspace: { workspaceUri: workspaceFile }, trusted: true } });
     StandaloneServices.get(ILogService).setLevel(LogLevel.Off);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-editor-wrapper",
-  "version": "4.0.0-monaco-update.2",
+  "version": "4.0.0-monaco-update.4",
   "private": false,
   "description": "Enhanced Monaco editor with TextMate grammars and more",
   "scripts": {
@@ -94,6 +94,7 @@
     "@codingame/monaco-vscode-language-detection-worker-service-override": "~2.0.0",
     "@codingame/monaco-vscode-languages-service-override": "~2.0.0",
     "@codingame/monaco-vscode-lifecycle-service-override": "~2.0.0",
+    "@codingame/monaco-vscode-log-service-override": "^2.0.1",
     "@codingame/monaco-vscode-lua-default-extension": "~2.0.0",
     "@codingame/monaco-vscode-markdown-basics-default-extension": "~2.0.0",
     "@codingame/monaco-vscode-markdown-language-features-default-extension": "~2.0.0",
@@ -130,6 +131,7 @@
     "@codingame/monaco-vscode-vb-default-extension": "~2.0.0",
     "@codingame/monaco-vscode-view-status-bar-service-override": "~2.0.0",
     "@codingame/monaco-vscode-views-service-override": "~2.0.0",
+    "@codingame/monaco-vscode-working-copy-service-override": "^2.0.1",
     "@codingame/monaco-vscode-xml-default-extension": "~2.0.0",
     "@codingame/monaco-vscode-yaml-default-extension": "~2.0.0",
     "monaco-editor": "npm:@codingame/monaco-vscode-editor-api@~2.0.0",