@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.2

package/dist/modelEditor.js

@@ -1,8 +1,7 @@
-import { _ as __decorate, a as __param, E as Emitter } from './workspace.js';
-import './polyfill.js';
-import { a as ILanguageDetectionService, u as unsupported } from './missing-services.js';
+import { _ as __decorate, a as __param, E as Emitter } from './contextkey.js';
+import { w as withUndefinedAsNull, A as AsyncReferenceCollection, R as ReferenceCollection } from './polyfill.js';
+import { L as LanguageDetectionLanguageEventSource, a as ILanguageDetectionService, u as unsupported } from './missing-services.js';
 import { MutableDisposable, Disposable, ImmortalReference, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { w as withUndefinedAsNull } from './types.js';
 import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
 import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
@@ -13,12 +12,11 @@ import { b as IEditorService, p as SIDE_GROUP, A as ACTIVE_GROUP, c as IFileServ
 import { MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { AbstractCodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/abstractCodeEditorService.js';
-import { isCodeEditor, isDiffEditor, getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { isCodeEditor, isDiffEditor, isCompositeEditor, getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
@@ -27,46 +25,6 @@ import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/comm
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-class ReferenceCollection {
-    constructor() {
-        this.references = ( (new Map()));
-    }
-    acquire(key, ...args) {
-        let reference = this.references.get(key);
-        if (!reference) {
-            reference = { counter: 0, object: this.createReferencedObject(key, ...args) };
-            this.references.set(key, reference);
-        }
-        const { object } = reference;
-        const dispose = once(() => {
-            if (--reference.counter === 0) {
-                this.destroyReferencedObject(key, reference.object);
-                this.references.delete(key);
-            }
-        });
-        reference.counter++;
-        return { object, dispose };
-    }
-}
-class AsyncReferenceCollection {
-    constructor(referenceCollection) {
-        this.referenceCollection = referenceCollection;
-    }
-    async acquire(key, ...args) {
-        const ref = this.referenceCollection.acquire(key, ...args);
-        try {
-            const object = await ref.object;
-            return {
-                object,
-                dispose: () => ref.dispose()
-            };
-        }
-        catch (error) {
-            ref.dispose();
-            throw error;
-        }
-    }
-}
 function isResolvedTextEditorModel(model) {
     const candidate = model;
     return !!candidate.textEditorModel;
@@ -95,11 +53,6 @@ function isTextEditorViewState(candidate) {
     const codeEditorViewState = viewState;
     return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));
 }
-function isCompositeEditor(thing) {
-    return !!thing
-        && typeof thing === 'object'
-        && typeof thing.onDidChangeActiveEditor === 'function';
-}
 class EditorModel extends Disposable {
     constructor() {
         super(...arguments);
@@ -159,18 +112,27 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
         return true;
     }
     get hasLanguageSetExplicitly() { return this._hasLanguageSetExplicitly; }
-    setLanguageId(languageId) {
+    setLanguageId(languageId, source) {
         this._hasLanguageSetExplicitly = true;
-        this.setLanguageIdInternal(languageId);
+        this.setLanguageIdInternal(languageId, source);
     }
-    setLanguageIdInternal(languageId) {
+    setLanguageIdInternal(languageId, source) {
         if (!this.isResolved()) {
             return;
         }
         if (!languageId || languageId === this.textEditorModel.getLanguageId()) {
             return;
         }
-        this.modelService.setMode(this.textEditorModel, this.languageService.createById(languageId));
+        this.modelService.setMode(this.textEditorModel, this.languageService.createById(languageId), source);
+    }
+    installModelListeners(model) {
+        const disposable = this._register(model.onDidChangeLanguage((e) => {
+            if (e.source === LanguageDetectionLanguageEventSource) {
+                return;
+            }
+            this._hasLanguageSetExplicitly = true;
+            disposable.dispose();
+        }));
     }
     getLanguageId() {
         return this.textEditorModel?.getLanguageId();
@@ -187,7 +149,7 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
         }
         const lang = await this.languageDetectionService.detectLanguage(this.textEditorModelHandle);
         if (lang && !this.isDisposed()) {
-            this.setLanguageIdInternal(lang);
+            this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
             const languageName = this.languageService.getLanguageName(lang);
             if (languageName) {
                 this.accessibilityService.alert(( (localize(
@@ -462,6 +424,18 @@ ResourceModelCollection = ( (__decorate([
     ( (__param(3, IModelService)))
 ], ResourceModelCollection)));
 let TextModelResolverService = class TextModelResolverService extends Disposable {
+    get resourceModelCollection() {
+        if (!this._resourceModelCollection) {
+            this._resourceModelCollection = this.instantiationService.createInstance(ResourceModelCollection);
+        }
+        return this._resourceModelCollection;
+    }
+    get asyncModelCollection() {
+        if (!this._asyncModelCollection) {
+            this._asyncModelCollection = ( (new AsyncReferenceCollection(this.resourceModelCollection)));
+        }
+        return this._asyncModelCollection;
+    }
     constructor(instantiationService, fileService, undoRedoService, modelService, uriIdentityService) {
         super();
         this.instantiationService = instantiationService;
@@ -469,8 +443,8 @@ let TextModelResolverService = class TextModelResolverService extends Disposable
         this.undoRedoService = undoRedoService;
         this.modelService = modelService;
         this.uriIdentityService = uriIdentityService;
-        this.resourceModelCollection = this.instantiationService.createInstance(ResourceModelCollection);
-        this.asyncModelCollection = ( (new AsyncReferenceCollection(this.resourceModelCollection)));
+        this._resourceModelCollection = undefined;
+        this._asyncModelCollection = undefined;
         this._register(( (new ModelUndoRedoParticipant(this.modelService, this, this.undoRedoService))));
     }
     async createModelReference(resource) {