@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

package/vscode/src/vs/workbench/contrib/editSessions/common/editSessions.js

@@ -0,0 +1,62 @@
+import { decodeBase64, VSBuffer } from '../../../../base/common/buffer.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { StringSHA1 } from '../../../../base/common/hash.js';
+const EDIT_SESSION_SYNC_CATEGORY = {
+    original: 'Cloud Changes',
+    value: ( localizeWithPath(
+        'vs/workbench/contrib/editSessions/common/editSessions',
+        'cloud changes',
+        'Cloud Changes'
+    ))
+};
+const IEditSessionsStorageService = ( createDecorator('IEditSessionsStorageService'));
+const IEditSessionsLogService = ( createDecorator('IEditSessionsLogService'));
+var ChangeType;
+( (function(ChangeType) {
+    ChangeType[ChangeType["Addition"] = 1] = "Addition";
+    ChangeType[ChangeType["Deletion"] = 2] = "Deletion";
+})(ChangeType || (ChangeType = {})));
+var FileType;
+( (function(FileType) {
+    FileType[FileType["File"] = 1] = "File";
+})(FileType || (FileType = {})));
+const EditSessionSchemaVersion = 3;
+const EDIT_SESSIONS_SIGNED_IN_KEY = 'editSessionsSignedIn';
+const EDIT_SESSIONS_SIGNED_IN = ( new RawContextKey(EDIT_SESSIONS_SIGNED_IN_KEY, false));
+const EDIT_SESSIONS_PENDING_KEY = 'editSessionsPending';
+const EDIT_SESSIONS_PENDING = ( new RawContextKey(EDIT_SESSIONS_PENDING_KEY, false));
+const EDIT_SESSIONS_CONTAINER_ID = 'workbench.view.editSessions';
+const EDIT_SESSIONS_DATA_VIEW_ID = 'workbench.views.editSessions.data';
+const EDIT_SESSIONS_TITLE = ( localize2WithPath(
+    'vs/workbench/contrib/editSessions/common/editSessions',
+    'cloud changes',
+    'Cloud Changes'
+));
+const EDIT_SESSIONS_VIEW_ICON = registerIcon('edit-sessions-view-icon', Codicon.cloudDownload, ( localizeWithPath(
+    'vs/workbench/contrib/editSessions/common/editSessions',
+    'editSessionViewIcon',
+    'View icon of the cloud changes view.'
+)));
+const EDIT_SESSIONS_SHOW_VIEW = ( new RawContextKey('editSessionsShowView', false));
+const EDIT_SESSIONS_SCHEME = 'vscode-edit-sessions';
+function decodeEditSessionFileContent(version, content) {
+    switch (version) {
+        case 1:
+            return VSBuffer.fromString(content);
+        case 2:
+            return decodeBase64(content);
+        default:
+            throw new Error('Upgrade to a newer version to decode this content.');
+    }
+}
+function hashedEditSessionId(editSessionId) {
+    const sha1 = ( new StringSHA1());
+    sha1.update(editSessionId);
+    return sha1.digest();
+}
+const editSessionsLogId = 'editSessions';
+export { ChangeType, EDIT_SESSIONS_CONTAINER_ID, EDIT_SESSIONS_DATA_VIEW_ID, EDIT_SESSIONS_PENDING, EDIT_SESSIONS_PENDING_KEY, EDIT_SESSIONS_SCHEME, EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_SIGNED_IN, EDIT_SESSIONS_SIGNED_IN_KEY, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_VIEW_ICON, EDIT_SESSION_SYNC_CATEGORY, EditSessionSchemaVersion, FileType, IEditSessionsLogService, IEditSessionsStorageService, decodeEditSessionFileContent, editSessionsLogId, hashedEditSessionId };

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/externalUriOpener.contribution.js

@@ -0,0 +1,5 @@
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { externalUriOpenersConfigurationNode } from './configuration.js';
+( Registry.as(Extensions.Configuration))
+    .registerConfiguration(externalUriOpenersConfigurationNode);

package/vscode/src/vs/workbench/contrib/files/browser/editors/binaryFileEditor.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { BaseBinaryResourceEditor } from '../../../../browser/parts/editor/binaryEditor.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import { FileEditorInput } from './fileEditorInput.js';
+import { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE } from '../../common/files.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.js';
+import { EditorResolution } from '../../../../../platform/editor/common/editor.js';
+import { IEditorResolverService } from '../../../../services/editor/common/editorResolverService.js';
+import { isEditorInputWithOptions } from '../../../../common/editor.js';
+import { DiffEditorInput } from '../../../../common/editor/diffEditorInput.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+var BinaryFileEditor_1;
+let BinaryFileEditor = class BinaryFileEditor extends BaseBinaryResourceEditor {
+    static { BinaryFileEditor_1 = this; }
+    static { this.ID = BINARY_FILE_EDITOR_ID; }
+    constructor(telemetryService, themeService, editorResolverService, storageService, editorGroupService) {
+        super(BinaryFileEditor_1.ID, {
+            openInternal: (input, options) => this.openInternal(input, options)
+        }, telemetryService, themeService, storageService);
+        this.editorResolverService = editorResolverService;
+        this.editorGroupService = editorGroupService;
+    }
+    async openInternal(input, options) {
+        if (input instanceof FileEditorInput && this.group?.activeEditor) {
+            const activeEditor = this.group.activeEditor;
+            const untypedActiveEditor = activeEditor?.toUntyped();
+            if (!untypedActiveEditor) {
+                return;
+            }
+            let resolvedEditor = await this.editorResolverService.resolveEditor({
+                ...untypedActiveEditor,
+                options: {
+                    ...options,
+                    override: EditorResolution.PICK
+                }
+            }, this.group);
+            if (resolvedEditor === 2 ) {
+                resolvedEditor = undefined;
+            }
+            else if (resolvedEditor === 1 ) {
+                return;
+            }
+            if (isEditorInputWithOptions(resolvedEditor)) {
+                for (const editor of resolvedEditor.editor instanceof DiffEditorInput ? [resolvedEditor.editor.original, resolvedEditor.editor.modified] : [resolvedEditor.editor]) {
+                    if (editor instanceof FileEditorInput) {
+                        editor.setForceOpenAsText();
+                        editor.setPreferredLanguageId(BINARY_TEXT_FILE_MODE);
+                    }
+                }
+            }
+            await (this.group ?? this.editorGroupService.activeGroup).replaceEditors([{
+                    editor: activeEditor,
+                    replacement: resolvedEditor?.editor ?? input,
+                    options: {
+                        ...(resolvedEditor?.options ?? options)
+                    }
+                }]);
+        }
+    }
+    getTitle() {
+        return this.input ? this.input.getName() : ( localizeWithPath(
+            'vs/workbench/contrib/files/browser/editors/binaryFileEditor',
+            'binaryFileEditor',
+            "Binary File Viewer"
+        ));
+    }
+};
+BinaryFileEditor = BinaryFileEditor_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IEditorResolverService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IEditorGroupsService))
+], BinaryFileEditor));
+export { BinaryFileEditor };

package/vscode/src/vs/workbench/contrib/files/browser/editors/fileEditorHandler.js

@@ -0,0 +1,72 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { ITextEditorService } from '../../../../services/textfile/common/textEditorService.js';
+import { isEqual } from '../../../../../base/common/resources.js';
+import { NO_TYPE_ID } from '../../../../services/workingCopy/common/workingCopy.js';
+import { IWorkingCopyEditorService } from '../../../../services/workingCopy/common/workingCopyEditorService.js';
+import { IFileService } from '../../../../../platform/files/common/files.js';
+class FileEditorInputSerializer {
+    canSerialize(editorInput) {
+        return true;
+    }
+    serialize(editorInput) {
+        const fileEditorInput = editorInput;
+        const resource = fileEditorInput.resource;
+        const preferredResource = fileEditorInput.preferredResource;
+        const serializedFileEditorInput = {
+            resourceJSON: resource.toJSON(),
+            preferredResourceJSON: isEqual(resource, preferredResource) ? undefined : preferredResource,
+            name: fileEditorInput.getPreferredName(),
+            description: fileEditorInput.getPreferredDescription(),
+            encoding: fileEditorInput.getEncoding(),
+            modeId: fileEditorInput.getPreferredLanguageId()
+        };
+        return JSON.stringify(serializedFileEditorInput);
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        return instantiationService.invokeFunction(accessor => {
+            const serializedFileEditorInput = JSON.parse(serializedEditorInput);
+            const resource = URI.revive(serializedFileEditorInput.resourceJSON);
+            const preferredResource = URI.revive(serializedFileEditorInput.preferredResourceJSON);
+            const name = serializedFileEditorInput.name;
+            const description = serializedFileEditorInput.description;
+            const encoding = serializedFileEditorInput.encoding;
+            const languageId = serializedFileEditorInput.modeId;
+            const fileEditorInput = accessor.get(ITextEditorService).createTextEditor({ resource, label: name, description, encoding, languageId, forceFile: true });
+            if (preferredResource) {
+                fileEditorInput.setPreferredResource(preferredResource);
+            }
+            return fileEditorInput;
+        });
+    }
+}
+let FileEditorWorkingCopyEditorHandler = class FileEditorWorkingCopyEditorHandler extends Disposable {
+    constructor(workingCopyEditorService, textEditorService, fileService) {
+        super();
+        this.textEditorService = textEditorService;
+        this.fileService = fileService;
+        this._register(workingCopyEditorService.registerHandler(this));
+    }
+    handles(workingCopy) {
+        return workingCopy.typeId === NO_TYPE_ID && this.fileService.canHandleResource(workingCopy.resource);
+    }
+    handlesSync(workingCopy) {
+        return workingCopy.typeId === NO_TYPE_ID && this.fileService.hasProvider(workingCopy.resource);
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handlesSync(workingCopy)) {
+            return false;
+        }
+        return isEqual(workingCopy.resource, editor.resource);
+    }
+    createEditor(workingCopy) {
+        return this.textEditorService.createTextEditor({ resource: workingCopy.resource, forceFile: true });
+    }
+};
+FileEditorWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IWorkingCopyEditorService)),
+    ( __param(1, ITextEditorService)),
+    ( __param(2, IFileService))
+], FileEditorWorkingCopyEditorHandler));
+export { FileEditorInputSerializer, FileEditorWorkingCopyEditorHandler };

package/vscode/src/vs/workbench/contrib/files/browser/editors/textFileEditor.js

@@ -0,0 +1,254 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { mark } from '../../../../../base/common/performance.js';
+import { assertIsDefined } from '../../../../../base/common/types.js';
+import { IPathService } from '../../../../services/path/common/pathService.js';
+import { toAction } from '../../../../../base/common/actions.js';
+import { TEXT_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, VIEWLET_ID } from '../../common/files.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.js';
+import { AbstractTextCodeEditor } from '../../../../browser/parts/editor/textCodeEditor.js';
+import { isTextEditorViewState, createEditorOpenError, createTooLargeFileError, DEFAULT_EDITOR_ASSOCIATION } from '../../../../common/editor.js';
+import { applyTextEditorOptions } from '../../../../common/editor/editorOptions.js';
+import { BinaryEditorModel } from '../../../../common/editor/binaryEditorModel.js';
+import { FileEditorInput } from './fileEditorInput.js';
+import { TooLargeFileOperationError, ByteSize, FileOperationError, IFileService } from '../../../../../platform/files/common/files.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.js';
+import { ITextResourceConfigurationService } from '../../../../../editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { EditorActivation } from '../../../../../platform/editor/common/editor.js';
+import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IExplorerService } from '../files.js';
+import { IPaneCompositePartService } from '../../../../services/panecomposite/browser/panecomposite.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IPreferencesService } from '../../../../services/preferences/common/preferences.js';
+import { IHostService } from '../../../../services/host/browser/host.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.js';
+var TextFileEditor_1;
+let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
+    static { TextFileEditor_1 = this; }
+    static { this.ID = TEXT_FILE_EDITOR_ID; }
+    constructor(telemetryService, fileService, paneCompositeService, instantiationService, contextService, storageService, textResourceConfigurationService, editorService, themeService, editorGroupService, textFileService, explorerService, uriIdentityService, pathService, configurationService, preferencesService, hostService, filesConfigurationService) {
+        super(TextFileEditor_1.ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);
+        this.paneCompositeService = paneCompositeService;
+        this.contextService = contextService;
+        this.textFileService = textFileService;
+        this.explorerService = explorerService;
+        this.uriIdentityService = uriIdentityService;
+        this.pathService = pathService;
+        this.configurationService = configurationService;
+        this.preferencesService = preferencesService;
+        this.hostService = hostService;
+        this.filesConfigurationService = filesConfigurationService;
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
+    }
+    onDidFilesChange(e) {
+        for (const resource of e.rawDeleted) {
+            this.clearEditorViewState(resource);
+        }
+    }
+    onDidRunOperation(e) {
+        if (e.operation === 2  && e.target) {
+            this.moveEditorViewState(e.resource, e.target.resource, this.uriIdentityService.extUri);
+        }
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return ( localizeWithPath(
+            'vs/workbench/contrib/files/browser/editors/textFileEditor',
+            'textFileEditor',
+            "Text File Editor"
+        ));
+    }
+    get input() {
+        return this._input;
+    }
+    async setInput(input, options, context, token) {
+        mark('code/willSetInputToTextFileEditor');
+        await super.setInput(input, options, context, token);
+        try {
+            const resolvedModel = await input.resolve(options);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            if (resolvedModel instanceof BinaryEditorModel) {
+                return this.openAsBinary(input, options);
+            }
+            const textFileModel = resolvedModel;
+            const control = assertIsDefined(this.editorControl);
+            control.setModel(textFileModel.textEditorModel);
+            if (!isTextEditorViewState(options?.viewState)) {
+                const editorViewState = this.loadEditorViewState(input, context);
+                if (editorViewState) {
+                    if (options?.selection) {
+                        editorViewState.cursorState = [];
+                    }
+                    control.restoreViewState(editorViewState);
+                }
+            }
+            if (options) {
+                applyTextEditorOptions(options, control, 1 );
+            }
+            control.updateOptions(this.getReadonlyConfiguration(textFileModel.isReadonly()));
+            if (control.handleInitialized) {
+                control.handleInitialized();
+            }
+        }
+        catch (error) {
+            await this.handleSetInputError(error, input, options);
+        }
+        mark('code/didSetInputToTextFileEditor');
+    }
+    async handleSetInputError(error, input, options) {
+        if (error.textFileOperationResult === 0 ) {
+            return this.openAsBinary(input, options);
+        }
+        if (error.fileOperationResult === 0 ) {
+            const actions = [];
+            actions.push(toAction({
+                id: 'workbench.files.action.openFolder', label: ( localizeWithPath(
+                'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                'openFolder',
+                "Open Folder"
+            )), run: async () => {
+                    return this.hostService.openWindow([{ folderUri: input.resource }], { forceNewWindow: true });
+                }
+            }));
+            if (this.contextService.isInsideWorkspace(input.preferredResource)) {
+                actions.push(toAction({
+                    id: 'workbench.files.action.reveal', label: ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                    'reveal',
+                    "Reveal Folder"
+                )), run: async () => {
+                        await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
+                        return this.explorerService.select(input.preferredResource, true);
+                    }
+                }));
+            }
+            throw createEditorOpenError(localizeWithPath('vs/workbench/contrib/files/browser/editors/textFileEditor', 'fileIsDirectory', "The file is not displayed in the text editor because it is a directory."), actions, { forceMessage: true });
+        }
+        if (error.fileOperationResult === 7  && this.group) {
+            let message;
+            if (error instanceof TooLargeFileOperationError) {
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                    'fileTooLargeForHeapErrorWithSize',
+                    "The file is not displayed in the text editor because it is very large ({0}).",
+                    ByteSize.formatSize(error.size)
+                ));
+            }
+            else {
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                    'fileTooLargeForHeapErrorWithoutSize',
+                    "The file is not displayed in the text editor because it is very large."
+                ));
+            }
+            throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
+        }
+        if (error.fileOperationResult === 1  &&
+            !this.filesConfigurationService.isReadonly(input.preferredResource) &&
+            (await this.pathService.hasValidBasename(input.preferredResource))) {
+            const fileNotFoundError = createEditorOpenError(( new FileOperationError(( localizeWithPath(
+                'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                'unavailableResourceErrorEditorText',
+                "The editor could not be opened because the file was not found."
+            )), 1 )), [
+                toAction({
+                    id: 'workbench.files.action.createMissingFile', label: ( localizeWithPath(
+                    'vs/workbench/contrib/files/browser/editors/textFileEditor',
+                    'createFile',
+                    "Create File"
+                )), run: async () => {
+                        await this.textFileService.create([{ resource: input.preferredResource }]);
+                        return this.editorService.openEditor({
+                            resource: input.preferredResource,
+                            options: {
+                                pinned: true
+                            }
+                        });
+                    }
+                })
+            ], {
+                allowDialog: true
+            });
+            throw fileNotFoundError;
+        }
+        throw error;
+    }
+    openAsBinary(input, options) {
+        const defaultBinaryEditor = this.configurationService.getValue('workbench.editor.defaultBinaryEditor');
+        const group = this.group ?? this.editorGroupService.activeGroup;
+        const editorOptions = {
+            ...options,
+            activation: EditorActivation.PRESERVE
+        };
+        if (defaultBinaryEditor && defaultBinaryEditor !== '' && defaultBinaryEditor !== DEFAULT_EDITOR_ASSOCIATION.id) {
+            this.doOpenAsBinaryInDifferentEditor(group, defaultBinaryEditor, input, editorOptions);
+        }
+        else {
+            this.doOpenAsBinaryInSameEditor(group, defaultBinaryEditor, input, editorOptions);
+        }
+    }
+    doOpenAsBinaryInDifferentEditor(group, editorId, editor, editorOptions) {
+        this.editorService.replaceEditors([{
+                editor,
+                replacement: { resource: editor.resource, options: { ...editorOptions, override: editorId } }
+            }], group);
+    }
+    doOpenAsBinaryInSameEditor(group, editorId, editor, editorOptions) {
+        if (editorId === DEFAULT_EDITOR_ASSOCIATION.id) {
+            editor.setForceOpenAsText();
+            editor.setPreferredLanguageId(BINARY_TEXT_FILE_MODE);
+            editorOptions = { ...editorOptions, forceReload: true };
+        }
+        else {
+            editor.setForceOpenAsBinary();
+        }
+        group.openEditor(editor, editorOptions);
+    }
+    clearInput() {
+        super.clearInput();
+        this.editorControl?.setModel(null);
+    }
+    createEditorControl(parent, initialOptions) {
+        mark('code/willCreateTextFileEditorControl');
+        super.createEditorControl(parent, initialOptions);
+        mark('code/didCreateTextFileEditorControl');
+    }
+    tracksEditorViewState(input) {
+        return input instanceof FileEditorInput;
+    }
+    tracksDisposedEditorViewState() {
+        return true;
+    }
+};
+TextFileEditor = TextFileEditor_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IPaneCompositePartService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, ITextResourceConfigurationService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IEditorGroupsService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, IExplorerService)),
+    ( __param(12, IUriIdentityService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IConfigurationService)),
+    ( __param(15, IPreferencesService)),
+    ( __param(16, IHostService)),
+    ( __param(17, IFilesConfigurationService))
+], TextFileEditor));
+export { TextFileEditor };

package/vscode/src/vs/workbench/contrib/files/browser/editors/textFileEditorTracker.js

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.js';
+import { ILifecycleService } from '../../../../services/lifecycle/common/lifecycle.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { distinct, coalesce } from '../../../../../base/common/arrays.js';
+import { IHostService } from '../../../../services/host/browser/host.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { RunOnceWorker } from '../../../../../base/common/async.js';
+import { ICodeEditorService } from '../../../../../editor/browser/services/codeEditorService.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { FILE_EDITOR_INPUT_ID } from '../../common/files.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { UntitledTextEditorInput } from '../../../../services/untitled/common/untitledTextEditorInput.js';
+import { IWorkingCopyEditorService } from '../../../../services/workingCopy/common/workingCopyEditorService.js';
+import { DEFAULT_EDITOR_ASSOCIATION } from '../../../../common/editor.js';
+let TextFileEditorTracker = class TextFileEditorTracker extends Disposable {
+    constructor(editorService, textFileService, lifecycleService, hostService, codeEditorService, filesConfigurationService, workingCopyEditorService) {
+        super();
+        this.editorService = editorService;
+        this.textFileService = textFileService;
+        this.lifecycleService = lifecycleService;
+        this.hostService = hostService;
+        this.codeEditorService = codeEditorService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.workingCopyEditorService = workingCopyEditorService;
+        this.ensureDirtyFilesAreOpenedWorker = this._register(( new RunOnceWorker(
+            units => this.ensureDirtyTextFilesAreOpened(units),
+            this.getDirtyTextFileTrackerDelay()
+        )));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.textFileService.files.onDidChangeDirty(model => this.ensureDirtyFilesAreOpenedWorker.work(model.resource)));
+        this._register(this.textFileService.files.onDidSaveError(model => this.ensureDirtyFilesAreOpenedWorker.work(model.resource)));
+        this._register(this.textFileService.untitled.onDidChangeDirty(model => this.ensureDirtyFilesAreOpenedWorker.work(model.resource)));
+        this._register(this.hostService.onDidChangeFocus(hasFocus => hasFocus ? this.reloadVisibleTextFileEditors() : undefined));
+        this._register(this.lifecycleService.onDidShutdown(() => this.dispose()));
+    }
+    getDirtyTextFileTrackerDelay() {
+        return 800;
+    }
+    ensureDirtyTextFilesAreOpened(resources) {
+        this.doEnsureDirtyTextFilesAreOpened(distinct(resources.filter(resource => {
+            if (!this.textFileService.isDirty(resource)) {
+                return false;
+            }
+            const fileModel = this.textFileService.files.get(resource);
+            if (fileModel?.hasState(2 )) {
+                return false;
+            }
+            if (resource.scheme !== Schemas.untitled && !fileModel?.hasState(5 ) && this.filesConfigurationService.hasShortAutoSaveDelay(resource)) {
+                return false;
+            }
+            if (this.editorService.isOpened({ resource, typeId: resource.scheme === Schemas.untitled ? UntitledTextEditorInput.ID : FILE_EDITOR_INPUT_ID, editorId: DEFAULT_EDITOR_ASSOCIATION.id })) {
+                return false;
+            }
+            const model = fileModel ?? this.textFileService.untitled.get(resource);
+            if (model && this.workingCopyEditorService.findEditor(model)) {
+                return false;
+            }
+            return true;
+        }), resource => ( resource.toString())));
+    }
+    doEnsureDirtyTextFilesAreOpened(resources) {
+        if (!resources.length) {
+            return;
+        }
+        this.editorService.openEditors(( resources.map(resource => ({
+            resource,
+            options: { inactive: true, pinned: true, preserveFocus: true }
+        }))));
+    }
+    reloadVisibleTextFileEditors() {
+        distinct(coalesce(( this.codeEditorService.listCodeEditors()
+            .map(codeEditor => {
+            const resource = codeEditor.getModel()?.uri;
+            if (!resource) {
+                return undefined;
+            }
+            const model = this.textFileService.files.get(resource);
+            if (!model || model.isDirty() || !model.isResolved()) {
+                return undefined;
+            }
+            return model;
+        }))), model => ( model.resource.toString())).forEach(model => this.textFileService.files.resolve(model.resource, { reload: { async: true } }));
+    }
+};
+TextFileEditorTracker = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IHostService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IFilesConfigurationService)),
+    ( __param(6, IWorkingCopyEditorService))
+], TextFileEditorTracker));
+export { TextFileEditorTracker };