@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common 20.0.0

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

@@ -0,0 +1,194 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION, isResourceMergeEditorInput, isResourceDiffEditorInput, isResourceSideBySideEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IUntitledTextEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
+import { SideBySideEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/sideBySideEditorInput';
+import { TextResourceEditorInput } from '@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { UntitledTextEditorInput } from '../../untitled/common/untitledTextEditorInput.js';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { RegisteredEditorPriority } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IEditorResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService.service';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+
+var TextEditorService_1;
+class FileEditorInputLeakError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.name = 'FileEditorInputLeakError';
+        this.stack = stack;
+    }
+}
+let TextEditorService = class TextEditorService extends Disposable {
+    static { TextEditorService_1 = this; }
+    constructor(untitledTextEditorService, instantiationService, uriIdentityService, fileService, editorResolverService) {
+        super();
+        this.untitledTextEditorService = untitledTextEditorService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.editorResolverService = editorResolverService;
+        this.editorInputCache = ( new ResourceMap());
+        this.fileEditorFactory = ( Registry.as(EditorExtensions.EditorFactory)).getFileEditorFactory();
+        this.mapLeakToCounter = ( new Map());
+        this.registerDefaultEditor();
+    }
+    registerDefaultEditor() {
+        this._register(this.editorResolverService.registerEditor('*', {
+            id: DEFAULT_EDITOR_ASSOCIATION.id,
+            label: DEFAULT_EDITOR_ASSOCIATION.displayName,
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.builtin
+        }, {}, {
+            createEditorInput: editor => ({ editor: this.createTextEditor(editor) }),
+            createUntitledEditorInput: untitledEditor => ({ editor: this.createTextEditor(untitledEditor) }),
+            createDiffEditorInput: diffEditor => ({ editor: this.createTextEditor(diffEditor) })
+        }));
+    }
+    async resolveTextEditor(input) {
+        return this.createTextEditor(input);
+    }
+    createTextEditor(input) {
+        if (isResourceMergeEditorInput(input)) {
+            return this.createTextEditor(input.result);
+        }
+        if (isResourceDiffEditorInput(input)) {
+            const original = this.createTextEditor(input.original);
+            const modified = this.createTextEditor(input.modified);
+            return this.instantiationService.createInstance(DiffEditorInput, input.label, input.description, original, modified, undefined);
+        }
+        if (isResourceSideBySideEditorInput(input)) {
+            const primary = this.createTextEditor(input.primary);
+            const secondary = this.createTextEditor(input.secondary);
+            return this.instantiationService.createInstance(SideBySideEditorInput, input.label, input.description, secondary, primary);
+        }
+        const untitledInput = input;
+        if (untitledInput.forceUntitled || !untitledInput.resource || (untitledInput.resource.scheme === Schemas.untitled)) {
+            const untitledOptions = {
+                languageId: untitledInput.languageId,
+                initialValue: untitledInput.contents,
+                encoding: untitledInput.encoding
+            };
+            let untitledModel;
+            if (untitledInput.resource?.scheme === Schemas.untitled) {
+                untitledModel = this.untitledTextEditorService.create({ untitledResource: untitledInput.resource, ...untitledOptions });
+            }
+            else {
+                untitledModel = this.untitledTextEditorService.create({ associatedResource: untitledInput.resource, ...untitledOptions });
+            }
+            return this.createOrGetCached(untitledModel.resource, () => this.instantiationService.createInstance(UntitledTextEditorInput, untitledModel));
+        }
+        const textResourceEditorInput = input;
+        if (textResourceEditorInput.resource instanceof URI) {
+            const label = textResourceEditorInput.label || basename(textResourceEditorInput.resource);
+            const preferredResource = textResourceEditorInput.resource;
+            const canonicalResource = this.uriIdentityService.asCanonicalUri(preferredResource);
+            return this.createOrGetCached(canonicalResource, () => {
+                if (textResourceEditorInput.forceFile || this.fileService.hasProvider(canonicalResource)) {
+                    return this.fileEditorFactory.createFileEditor(canonicalResource, preferredResource, textResourceEditorInput.label, textResourceEditorInput.description, textResourceEditorInput.encoding, textResourceEditorInput.languageId, textResourceEditorInput.contents, this.instantiationService);
+                }
+                return this.instantiationService.createInstance(TextResourceEditorInput, canonicalResource, textResourceEditorInput.label, textResourceEditorInput.description, textResourceEditorInput.languageId, textResourceEditorInput.contents);
+            }, cachedInput => {
+                if (cachedInput instanceof UntitledTextEditorInput) {
+                    return;
+                }
+                else if (!(cachedInput instanceof TextResourceEditorInput)) {
+                    cachedInput.setPreferredResource(preferredResource);
+                    if (textResourceEditorInput.label) {
+                        cachedInput.setPreferredName(textResourceEditorInput.label);
+                    }
+                    if (textResourceEditorInput.description) {
+                        cachedInput.setPreferredDescription(textResourceEditorInput.description);
+                    }
+                    if (textResourceEditorInput.encoding) {
+                        cachedInput.setPreferredEncoding(textResourceEditorInput.encoding);
+                    }
+                    if (textResourceEditorInput.languageId) {
+                        cachedInput.setPreferredLanguageId(textResourceEditorInput.languageId);
+                    }
+                    if (typeof textResourceEditorInput.contents === 'string') {
+                        cachedInput.setPreferredContents(textResourceEditorInput.contents);
+                    }
+                }
+                else {
+                    if (label) {
+                        cachedInput.setName(label);
+                    }
+                    if (textResourceEditorInput.description) {
+                        cachedInput.setDescription(textResourceEditorInput.description);
+                    }
+                    if (textResourceEditorInput.languageId) {
+                        cachedInput.setPreferredLanguageId(textResourceEditorInput.languageId);
+                    }
+                    if (typeof textResourceEditorInput.contents === 'string') {
+                        cachedInput.setPreferredContents(textResourceEditorInput.contents);
+                    }
+                }
+            });
+        }
+        throw ( new Error(
+            `ITextEditorService: Unable to create texteditor from ${JSON.stringify(input)}`
+        ));
+    }
+    createOrGetCached(resource, factoryFn, cachedFn) {
+        let input = this.editorInputCache.get(resource);
+        if (input) {
+            cachedFn?.(input);
+            return input;
+        }
+        input = factoryFn();
+        this.editorInputCache.set(resource, input);
+        const leakId = this.trackLeaks(input);
+        Event.once(input.onWillDispose)(() => {
+            this.editorInputCache.delete(resource);
+            if (leakId) {
+                this.untrackLeaks(leakId);
+            }
+        });
+        return input;
+    }
+    static { this.LEAK_TRACKING_THRESHOLD = 256; }
+    static { this.LEAK_REPORTING_THRESHOLD = 2 * this.LEAK_TRACKING_THRESHOLD; }
+    static { this.LEAK_REPORTED = false; }
+    trackLeaks(input) {
+        if (TextEditorService_1.LEAK_REPORTED || this.editorInputCache.size < TextEditorService_1.LEAK_TRACKING_THRESHOLD) {
+            return undefined;
+        }
+        const leakId = `${input.resource.scheme}#${input.typeId || '<no typeId>'}#${input.editorId || '<no editorId>'}\n${( new Error()).stack?.split('\n').slice(2).join('\n') ?? ''}`;
+        const leakCounter = (this.mapLeakToCounter.get(leakId) ?? 0) + 1;
+        this.mapLeakToCounter.set(leakId, leakCounter);
+        if (this.editorInputCache.size > TextEditorService_1.LEAK_REPORTING_THRESHOLD) {
+            TextEditorService_1.LEAK_REPORTED = true;
+            const [topLeak, topCount] = Array.from(this.mapLeakToCounter.entries()).reduce(([topLeak, topCount], [key, val]) => val > topCount ? [key, val] : [topLeak, topCount]);
+            const message = `Potential text editor input LEAK detected, having ${this.editorInputCache.size} text editor inputs already. Most frequent owner (${topCount})`;
+            onUnexpectedError(( new FileEditorInputLeakError(message, topLeak)));
+        }
+        return leakId;
+    }
+    untrackLeaks(leakId) {
+        const stackCounter = (this.mapLeakToCounter.get(leakId) ?? 1) - 1;
+        this.mapLeakToCounter.set(leakId, stackCounter);
+        if (stackCounter === 0) {
+            this.mapLeakToCounter.delete(leakId);
+        }
+    }
+};
+TextEditorService = TextEditorService_1 = ( __decorate([
+    ( __param(0, IUntitledTextEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IEditorResolverService))
+], TextEditorService));
+
+export { TextEditorService };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorInput.d.ts

@@ -0,0 +1,45 @@
+import { IUntitledTextResourceEditorInput, IUntypedEditorInput, Verbosity } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput, IUntypedEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { AbstractTextResourceEditorInput } from "@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/common/editor/textResourceEditorInput";
+import { IUntitledTextEditorModel } from "@codingame/monaco-vscode-0c06bfba-d24d-5c4d-90cd-b40cefb7f811-common/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel";
+import { EncodingMode, IEncodingSupport, ILanguageSupport } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { ICustomEditorLabelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/customEditorLabelService.service";
+export declare class UntitledTextEditorInput extends AbstractTextResourceEditorInput implements IEncodingSupport, ILanguageSupport {
+    protected model: IUntitledTextEditorModel;
+    private readonly environmentService;
+    private readonly pathService;
+    private readonly textModelService;
+    static readonly ID: string;
+    get typeId(): string;
+    get editorId(): string | undefined;
+    private modelResolve;
+    private readonly modelDisposables;
+    private cachedUntitledTextEditorModelReference;
+    constructor(model: IUntitledTextEditorModel, textFileService: ITextFileService, labelService: ILabelService, editorService: IEditorService, fileService: IFileService, environmentService: IWorkbenchEnvironmentService, pathService: IPathService, filesConfigurationService: IFilesConfigurationService, textModelService: ITextModelService, textResourceConfigurationService: ITextResourceConfigurationService, customEditorLabelService: ICustomEditorLabelService);
+    private registerModelListeners;
+    private onDidCreateUntitledModel;
+    getName(): string;
+    getDescription(verbosity?: Verbosity): string | undefined;
+    getTitle(verbosity: Verbosity): string;
+    isDirty(): boolean;
+    getEncoding(): string | undefined;
+    setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
+    get hasLanguageSetExplicitly(): boolean;
+    get hasAssociatedFilePath(): boolean;
+    setLanguageId(languageId: string, source?: string): void;
+    getLanguageId(): string | undefined;
+    resolve(): Promise<IUntitledTextEditorModel>;
+    toUntyped(options?: IUntypedEditorOptions): IUntitledTextResourceEditorInput;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    dispose(): void;
+    private disposeModelReference;
+}

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorInput.js

@@ -0,0 +1,159 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DEFAULT_EDITOR_ASSOCIATION, Verbosity, findViewStateForEditor, isUntitledResourceEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { AbstractTextResourceEditorInput } from '@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { isEqual, toLocalResource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ITextResourceConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service';
+import { ICustomEditorLabelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/customEditorLabelService.service';
+
+var UntitledTextEditorInput_1;
+let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractTextResourceEditorInput {
+    static { UntitledTextEditorInput_1 = this; }
+    static { this.ID = 'workbench.editors.untitledEditorInput'; }
+    get typeId() {
+        return UntitledTextEditorInput_1.ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService, filesConfigurationService, textModelService, textResourceConfigurationService, customEditorLabelService) {
+        super(model.resource, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService, textResourceConfigurationService, customEditorLabelService);
+        this.model = model;
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+        this.textModelService = textModelService;
+        this.modelResolve = undefined;
+        this.modelDisposables = this._register(( new DisposableStore()));
+        this.cachedUntitledTextEditorModelReference = undefined;
+        this.registerModelListeners(model);
+        this._register(this.textFileService.untitled.onDidCreate(model => this.onDidCreateUntitledModel(model)));
+    }
+    registerModelListeners(model) {
+        this.modelDisposables.clear();
+        this.modelDisposables.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this.modelDisposables.add(model.onDidChangeName(() => this._onDidChangeLabel.fire()));
+        this.modelDisposables.add(model.onDidRevert(() => this.dispose()));
+    }
+    onDidCreateUntitledModel(model) {
+        if (isEqual(model.resource, this.model.resource) && model !== this.model) {
+            this.model = model;
+            this.registerModelListeners(model);
+        }
+    }
+    getName() {
+        return this.model.name;
+    }
+    getDescription(verbosity = Verbosity.MEDIUM) {
+        if (!this.model.hasAssociatedFilePath) {
+            const descriptionCandidate = this.resource.path;
+            if (descriptionCandidate !== this.getName()) {
+                return descriptionCandidate;
+            }
+            return undefined;
+        }
+        return super.getDescription(verbosity);
+    }
+    getTitle(verbosity) {
+        if (!this.model.hasAssociatedFilePath) {
+            const name = this.getName();
+            const description = this.getDescription();
+            if (description && description !== name) {
+                return `${name} • ${description}`;
+            }
+            return name;
+        }
+        return super.getTitle(verbosity);
+    }
+    isDirty() {
+        return this.model.isDirty();
+    }
+    getEncoding() {
+        return this.model.getEncoding();
+    }
+    setEncoding(encoding, mode ) {
+        return this.model.setEncoding(encoding);
+    }
+    get hasLanguageSetExplicitly() { return this.model.hasLanguageSetExplicitly; }
+    get hasAssociatedFilePath() { return this.model.hasAssociatedFilePath; }
+    setLanguageId(languageId, source) {
+        this.model.setLanguageId(languageId, source);
+    }
+    getLanguageId() {
+        return this.model.getLanguageId();
+    }
+    async resolve() {
+        if (!this.modelResolve) {
+            this.modelResolve = (async () => {
+                this.cachedUntitledTextEditorModelReference = await this.textModelService.createModelReference(this.resource);
+            })();
+        }
+        await this.modelResolve;
+        if (this.isDisposed()) {
+            this.disposeModelReference();
+        }
+        return this.model;
+    }
+    toUntyped(options) {
+        const untypedInput = {
+            resource: this.model.hasAssociatedFilePath ? toLocalResource(this.model.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme) : this.resource,
+            forceUntitled: true,
+            options: {
+                override: this.editorId
+            }
+        };
+        if (typeof options?.preserveViewState === 'number') {
+            untypedInput.encoding = this.getEncoding();
+            untypedInput.languageId = this.getLanguageId();
+            untypedInput.contents = this.model.isModified() ? this.model.textEditorModel?.getValue() : undefined;
+            untypedInput.options.viewState = findViewStateForEditor(this, options.preserveViewState, this.editorService);
+            if (typeof untypedInput.contents === 'string' && !this.model.hasAssociatedFilePath && !options.preserveResource) {
+                untypedInput.resource = undefined;
+            }
+        }
+        return untypedInput;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof UntitledTextEditorInput_1) {
+            return isEqual(otherInput.resource, this.resource);
+        }
+        if (isUntitledResourceEditorInput(otherInput)) {
+            return super.matches(otherInput);
+        }
+        return false;
+    }
+    dispose() {
+        this.modelResolve = undefined;
+        this.disposeModelReference();
+        super.dispose();
+    }
+    disposeModelReference() {
+        dispose(this.cachedUntitledTextEditorModelReference);
+        this.cachedUntitledTextEditorModelReference = undefined;
+    }
+};
+UntitledTextEditorInput = UntitledTextEditorInput_1 = ( __decorate([
+    ( __param(1, ITextFileService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IPathService)),
+    ( __param(7, IFilesConfigurationService)),
+    ( __param(8, ITextModelService)),
+    ( __param(9, ITextResourceConfigurationService)),
+    ( __param(10, ICustomEditorLabelService))
+], UntitledTextEditorInput));
+
+export { UntitledTextEditorInput };