@codingame/monaco-vscode-api 1.76.1 → 1.76.3-next.0

package/dist/modelEditor.d.ts

@@ -1,5 +1,279 @@
 import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode';
 
+/**
+ * An object that performs a cleanup operation when `.dispose()` is called.
+ *
+ * Some examples of how disposables are used:
+ *
+ * - An event listener that removes itself when `.dispose()` is called.
+ * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
+ * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
+ */
+interface IDisposable {
+    dispose(): void;
+}
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
+declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private readonly _toDispose;
+    private _isDisposed;
+    constructor();
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
+    dispose(): void;
+    /**
+     * @return `true` if this object has been disposed of.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
+    add<T extends IDisposable>(o: T): T;
+}
+interface IReference<T> extends IDisposable {
+    readonly object: T;
+}
+
+interface IObservable<T, TChange = void> {
+    readonly TChange: TChange;
+    /**
+     * Reads the current value.
+     *
+     * Must not be called from {@link IObserver.handleChange}.
+     */
+    get(): T;
+    /**
+     * Adds an observer.
+     */
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    /**
+     * Subscribes the reader to this observable and returns the current value of this observable.
+     */
+    read(reader: IReader): T;
+    map<TNew>(fn: (value: T) => TNew): IObservable<TNew>;
+    readonly debugName: string;
+}
+interface IReader {
+    /**
+     * Reports an observable that was read.
+     *
+     * Is called by {@link IObservable.read}.
+     */
+    subscribeTo<T>(observable: IObservable<T, any>): void;
+}
+interface IObserver {
+    /**
+     * Indicates that an update operation is about to begin.
+     *
+     * During an update, invariants might not hold for subscribed observables and
+     * change events might be delayed.
+     * However, all changes must be reported before all update operations are over.
+     */
+    beginUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Is called by a subscribed observable immediately after it notices a change.
+     *
+     * When {@link IObservable.get} returns and no change has been reported,
+     * there has been no change for that observable.
+     *
+     * Implementations must not call into other observables!
+     * The change should be processed when {@link IObserver.endUpdate} is called.
+     */
+    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    /**
+     * Indicates that an update operation has completed.
+     */
+    endUpdate<T>(observable: IObservable<T>): void;
+}
+
+/**
+ * Can be passed into the Delayed to defer using a microtask
+ * */
+declare const MicrotaskDelay: unique symbol;
+
+/**
+ * An event with zero or one parameters that can be subscribed to. The event is a function itself.
+ */
+type Event<T> = vscode.Event<T>
+declare namespace Event {
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
+     * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
+     * result of merging events and to try prevent race conditions that could arise when using related deferred and
+     * non-deferred events.
+     *
+     * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
+     * (eg. latency of keypress to text rendered).
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
+    /**
+     * Given an event, returns another event which only fires once.
+     *
+     * @param event The event source for the new event.
+     */
+    function once<T>(event: Event<T>): Event<T>;
+    /**
+     * Maps an event of one type into an event of another type using a mapping function, similar to how
+     * `Array.prototype.map` works.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param map The mapping function.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
+    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
+    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
+    /**
+     * Given an event, returns the same event but typed as `Event<void>`.
+     */
+    function signal<T>(event: Event<T>): Event<void>;
+    /**
+     * Given a collection of events, returns a single event which emits
+     * whenever any of the provided events emit.
+     */
+    function any<T>(...events: Event<T>[]): Event<T>;
+    function any(...events: Event<any>[]): Event<void>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
+    /**
+     * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an
+     * array event object of all events that fired.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The original event to debounce.
+     * @param merge A function that reduces all events into a single event.
+     * @param delay The number of milliseconds to debounce.
+     * @param leading Whether to fire a leading event without debouncing.
+     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
+     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
+     * listener gets disposed before the debounced event fires.
+     * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
+     * @param disposable A disposable store to register the debounce emitter to.
+     */
+    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    /**
+     * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function accumulate<T>(event: Event<T>, delay?: number, disposable?: DisposableStore): Event<T[]>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
+    /**
+     * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @example
+     * ```
+     * const event = new EventEmitter<number | undefined>().event;
+     * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
+     * ```
+     *
+     * @param event The event source for the new event.
+     * @param isT A function that determines what event is of the first type.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
+    interface IChainableEvent<T> extends IDisposable {
+        event: Event<T>;
+        map<O>(fn: (i: T) => O): IChainableEvent<O>;
+        forEach(fn: (i: T) => void): IChainableEvent<T>;
+        filter(fn: (e: T) => boolean): IChainableEvent<T>;
+        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
+        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
+        latch(): IChainableEvent<T>;
+        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
+        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
+        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
+    }
+    function chain<T>(event: Event<T>): IChainableEvent<T>;
+    interface NodeEventEmitter {
+        on(event: string | symbol, listener: Function): unknown;
+        removeListener(event: string | symbol, listener: Function): unknown;
+    }
+    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    interface DOMEventEmitter {
+        addEventListener(event: string | symbol, listener: Function): void;
+        removeEventListener(event: string | symbol, listener: Function): void;
+    }
+    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    function toPromise<T>(event: Event<T>): Promise<T>;
+    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
+    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
+    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
+}
+
+/**
+ * Text snapshot that works like an iterator.
+ * Will try to return chunks of roughly ~64KB size.
+ * Will return null when finished.
+ */
+interface ITextSnapshot {
+    read(): string | null;
+}
 /**
  * A model.
  */
@@ -10,6 +284,28 @@ type ITextModel = monaco.editor.ITextModel
  */
 type ICodeEditor = monaco.editor.ICodeEditor
 
+interface IEditorModel {
+    /**
+     * Emitted when the model is about to be disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Resolves the model.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Find out if the editor model was resolved or not.
+     */
+    isResolved(): boolean;
+    /**
+     * Find out if this model has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Dispose associated resources
+     */
+    dispose(): void;
+}
 declare enum EditorActivation {
     /**
      * Activate the editor after it opened. This will automatically restore
@@ -154,7 +450,33 @@ interface IEditorOptions {
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
-type OpenEditor = (model: ITextModel, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
+interface ITextEditorModel extends IEditorModel {
+    /**
+     * Provides access to the underlying `ITextModel`.
+     */
+    readonly textEditorModel: ITextModel | null;
+    /**
+     * Creates a snapshot of the model's contents.
+     */
+    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
+    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
+    /**
+     * Signals if this model is readonly or not.
+     */
+    isReadonly(): boolean;
+    /**
+     * The language id of the text model if known.
+     */
+    getLanguageId(): string | undefined;
+}
+interface IResolvedTextEditorModel extends ITextEditorModel {
+    /**
+     * Same as ITextEditorModel#textEditorModel, but never null.
+     */
+    readonly textEditorModel: ITextModel;
+}
+
+type OpenEditor = (modelRef: IReference<IResolvedTextEditorModel>, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
 declare function getServiceOverride(openEditor: OpenEditor): IEditorOverrideServices;
 
-export { IEditorOptions, OpenEditor, getServiceOverride as default };
+export { IEditorOptions, IReference, IResolvedTextEditorModel, OpenEditor, getServiceOverride as default };

package/dist/modelEditor.js

@@ -1,14 +1,11 @@
-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 { 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';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { I as IEditorService, S as SIDE_GROUP, A as ACTIVE_GROUP, _ as __decorate, a as __param, E as Emitter, n as IFileService, j as IUriIdentityService, H as isPreferredGroup, l as ITextFileService } from './services2.js';
+import { A as AsyncReferenceCollection, g as ReferenceCollection } from './polyfill.js';
+import { u as unsupported, bN as isResourceEditorInput, bO as isEditorInput, bP as ILanguageDetectionService, bQ as isTextEditorViewState } from './missing-services.js';
+import { B as BaseTextEditorModel, T as TextFileEditorModel } from './textFileEditorModel.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { b as IEditorService, p as SIDE_GROUP, A as ACTIVE_GROUP, c as IFileService, k as IUriIdentityService, q as isPreferredGroup, j as ITextFileService } from './services2.js';
+import { Disposable, ImmortalReference, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 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';
@@ -29,206 +26,6 @@ function isResolvedTextEditorModel(model) {
     const candidate = model;
     return !!candidate.textEditorModel;
 }
-function isResourceEditorInput(editor) {
-    if (isEditorInput(editor)) {
-        return false;
-    }
-    const candidate = editor;
-    return URI.isUri(candidate?.resource);
-}
-class AbstractEditorInput extends Disposable {
-}
-function isEditorInput(editor) {
-    return editor instanceof AbstractEditorInput;
-}
-function isTextEditorViewState(candidate) {
-    const viewState = candidate;
-    if (!viewState) {
-        return false;
-    }
-    const diffEditorViewState = viewState;
-    if (diffEditorViewState.modified) {
-        return isTextEditorViewState(diffEditorViewState.modified);
-    }
-    const codeEditorViewState = viewState;
-    return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));
-}
-class EditorModel extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._onWillDispose = this._register(( (new Emitter())));
-        this.onWillDispose = this._onWillDispose.event;
-        this.disposed = false;
-        this.resolved = false;
-    }
-    async resolve() {
-        this.resolved = true;
-    }
-    isResolved() {
-        return this.resolved;
-    }
-    isDisposed() {
-        return this.disposed;
-    }
-    dispose() {
-        this.disposed = true;
-        this._onWillDispose.fire();
-        super.dispose();
-    }
-}
-let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
-    constructor(modelService, languageService, languageDetectionService, accessibilityService, textEditorModelHandle) {
-        super();
-        this.modelService = modelService;
-        this.languageService = languageService;
-        this.languageDetectionService = languageDetectionService;
-        this.accessibilityService = accessibilityService;
-        this.textEditorModelHandle = undefined;
-        this.modelDisposeListener = this._register(( (new MutableDisposable())));
-        this.autoDetectLanguageThrottler = this._register(( (new ThrottledDelayer(BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY))));
-        this._hasLanguageSetExplicitly = false;
-        if (textEditorModelHandle) {
-            this.handleExistingModel(textEditorModelHandle);
-        }
-    }
-    handleExistingModel(textEditorModelHandle) {
-        const model = this.modelService.getModel(textEditorModelHandle);
-        if (!model) {
-            throw new Error(`Document with resource ${textEditorModelHandle.toString(true)} does not exist`);
-        }
-        this.textEditorModelHandle = textEditorModelHandle;
-        this.registerModelDisposeListener(model);
-    }
-    registerModelDisposeListener(model) {
-        this.modelDisposeListener.value = model.onWillDispose(() => {
-            this.textEditorModelHandle = undefined;
-            this.dispose();
-        });
-    }
-    get textEditorModel() {
-        return this.textEditorModelHandle ? this.modelService.getModel(this.textEditorModelHandle) : null;
-    }
-    isReadonly() {
-        return true;
-    }
-    get hasLanguageSetExplicitly() { return this._hasLanguageSetExplicitly; }
-    setLanguageId(languageId, source) {
-        this._hasLanguageSetExplicitly = true;
-        this.setLanguageIdInternal(languageId, source);
-    }
-    setLanguageIdInternal(languageId, source) {
-        if (!this.isResolved()) {
-            return;
-        }
-        if (!languageId || languageId === this.textEditorModel.getLanguageId()) {
-            return;
-        }
-        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();
-    }
-    autoDetectLanguage() {
-        return this.autoDetectLanguageThrottler.trigger(() => this.doAutoDetectLanguage());
-    }
-    async doAutoDetectLanguage() {
-        if (this.hasLanguageSetExplicitly ||
-            !this.textEditorModelHandle ||
-            !this.languageDetectionService.isEnabledForLanguage(this.getLanguageId() ?? PLAINTEXT_LANGUAGE_ID)
-        ) {
-            return;
-        }
-        const lang = await this.languageDetectionService.detectLanguage(this.textEditorModelHandle);
-        if (lang && !this.isDisposed()) {
-            this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
-            const languageName = this.languageService.getLanguageName(lang);
-            if (languageName) {
-                this.accessibilityService.alert(( (localize(
-                    'languageAutoDetected',
-                    "Language {0} was automatically detected and set as the language mode.",
-                    languageName
-                ))));
-            }
-        }
-    }
-    createTextEditorModel(value, resource, preferredLanguageId) {
-        const firstLineText = this.getFirstLineText(value);
-        const languageSelection = this.getOrCreateLanguage(resource, this.languageService, preferredLanguageId, firstLineText);
-        return this.doCreateTextEditorModel(value, languageSelection, resource);
-    }
-    doCreateTextEditorModel(value, languageSelection, resource) {
-        let model = resource && this.modelService.getModel(resource);
-        if (!model) {
-            model = this.modelService.createModel(value, languageSelection, resource);
-            this.createdEditorModel = true;
-            this.registerModelDisposeListener(model);
-        }
-        else {
-            this.updateTextEditorModel(value, languageSelection.languageId);
-        }
-        this.textEditorModelHandle = model.uri;
-        return model;
-    }
-    getFirstLineText(value) {
-        const textBufferFactory = value;
-        if (typeof textBufferFactory.getFirstLineText === 'function') {
-            return textBufferFactory.getFirstLineText(1000 );
-        }
-        const textSnapshot = value;
-        return textSnapshot.getLineContent(1).substr(0, 1000 );
-    }
-    getOrCreateLanguage(resource, languageService, preferredLanguage, firstLineText) {
-        if (!preferredLanguage || preferredLanguage === PLAINTEXT_LANGUAGE_ID) {
-            return languageService.createByFilepathOrFirstLine(withUndefinedAsNull(resource), firstLineText);
-        }
-        return languageService.createById(preferredLanguage);
-    }
-    updateTextEditorModel(newValue, preferredLanguageId) {
-        if (!this.isResolved()) {
-            return;
-        }
-        if (newValue) {
-            this.modelService.updateModel(this.textEditorModel, newValue);
-        }
-        if (preferredLanguageId && preferredLanguageId !== PLAINTEXT_LANGUAGE_ID && this.textEditorModel.getLanguageId() !== preferredLanguageId) {
-            this.modelService.setMode(this.textEditorModel, this.languageService.createById(preferredLanguageId));
-        }
-    }
-    createSnapshot() {
-        if (!this.textEditorModel) {
-            return null;
-        }
-        return this.textEditorModel.createSnapshot(true );
-    }
-    isResolved() {
-        return !!this.textEditorModelHandle;
-    }
-    dispose() {
-        this.modelDisposeListener.dispose();
-        if (this.textEditorModelHandle && this.createdEditorModel) {
-            this.modelService.destroyModel(this.textEditorModelHandle);
-        }
-        this.textEditorModelHandle = undefined;
-        this.createdEditorModel = false;
-        super.dispose();
-    }
-};
-BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY = 600;
-BaseTextEditorModel = ( (__decorate([
-    ( (__param(0, IModelService))),
-    ( (__param(1, ILanguageService))),
-    ( (__param(2, ILanguageDetectionService))),
-    ( (__param(3, IAccessibilityService)))
-], BaseTextEditorModel)));
 let TextResourceEditorModel = class TextResourceEditorModel extends BaseTextEditorModel {
     constructor(resource, languageService, modelService, languageDetectionService, accessibilityService) {
         super(modelService, languageService, languageDetectionService, accessibilityService, resource);
@@ -246,7 +43,6 @@ TextResourceEditorModel = ( (__decorate([
     ( (__param(3, ILanguageDetectionService))),
     ( (__param(4, IAccessibilityService)))
 ], TextResourceEditorModel)));
-class TextFileEditorModel {}
 let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
     constructor(_modelService, _textModelService, _undoRedoService) {
         super();
@@ -275,7 +71,7 @@ let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable
         if (missingModels.length === 0) {
             return Disposable.None;
         }
-        const disposablesPromises = missingModels.map(async (uri) => {
+        const disposablesPromises = ( (missingModels.map(async (uri) => {
             try {
                 const reference = await this._textModelService.createModelReference(uri);
                 return reference;
@@ -283,7 +79,7 @@ let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable
             catch (err) {
                 return Disposable.None;
             }
-        });
+        })));
         return Promise.all(disposablesPromises).then(disposables => {
             return {
                 dispose: () => dispose(disposables)
@@ -635,8 +431,8 @@ let EditorService = class EditorService extends Disposable {
         this.isOpened = () => false;
         this.isVisible = () => false;
         this.findEditors = () => [];
-        this.save = unsupported;
-        this.saveAll = unsupported;
+        this.save = async () => true;
+        this.saveAll = async () => true;
         this.revert = unsupported;
         this.revertAll = unsupported;
         this.closeEditor = unsupported;
@@ -669,23 +465,14 @@ let EditorService = class EditorService extends Disposable {
             throw new Error('Diff editors not supported');
         }
         let modelEditor;
-        const modelService = StandaloneServices.get(IModelService);
-        let model = modelService.getModel(resource);
-        let newModelRef;
-        if (model == null) {
-            const modelRef = await this.textModelService.createModelReference(resource);
-            newModelRef = modelRef;
-            model = modelRef.object.textEditorModel;
-        }
-        else {
-            const codeEditors = StandaloneServices.get(ICodeEditorService).listCodeEditors();
-            modelEditor = codeEditors.find(editor => editor.getModel() === model);
-        }
+        const modelRef = await this.textModelService.createModelReference(resource);
+        const codeEditors = StandaloneServices.get(ICodeEditorService).listCodeEditors();
+        modelEditor = codeEditors.find(editor => editor.getModel() === modelRef.object.textEditorModel);
         if (modelEditor == null) {
-            modelEditor = await this._openEditor(model, options, preferredGroup === SIDE_GROUP);
+            modelEditor = await this._openEditor(modelRef, options, preferredGroup === SIDE_GROUP);
         }
         if (modelEditor == null) {
-            newModelRef?.dispose();
+            modelRef.dispose();
             return undefined;
         }
         if (options != null) {