@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,230 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IPathService } from '../../../../services/path/common/pathService.js';
-import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { TEXT_FILE_EDITOR_ID, VIEWLET_ID, BINARY_TEXT_FILE_MODE } 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 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.js';
-import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
-import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IExplorerService } from '../files.js';
-import { IPaneCompositePartService } from '../../../../services/panecomposite/browser/panecomposite.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IPreferencesService } from '../../../../services/preferences/common/preferences.js';
-import { IHostService } from '../../../../services/host/browser/host.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) {
-        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._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 ( localize('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: ( localize('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: ( localize('reveal', "Reveal Folder")), run: async () => {
-                        await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
-                        return this.explorerService.select(input.preferredResource, true);
-                    }
-                }));
-            }
-            throw createEditorOpenError(localize('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 = ( localize(
-                    'fileTooLargeForHeapErrorWithSize',
-                    "The file is not displayed in the text editor because it is very large ({0}).",
-                    ByteSize.formatSize(error.size)
-                ));
-            }
-            else {
-                message = ( localize(
-                    '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  && (await this.pathService.hasValidBasename(input.preferredResource))) {
-            const fileNotFoundError = createEditorOpenError(( new FileOperationError(( localize(
-                'unavailableResourceErrorEditorText',
-                "The editor could not be opened because the file was not found."
-            )), 1 )), [
-                toAction({
-                    id: 'workbench.files.action.createMissingFile', label: ( localize('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))
-], TextFileEditor));
-export { TextFileEditor };

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

@@ -1,97 +0,0 @@
-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 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { distinct, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { IHostService } from '../../../../services/host/browser/host.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.js';
-import { RunOnceWorker } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/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 'monaco-editor/esm/vs/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 && this.filesConfigurationService.getAutoSaveMode() === 1  && !fileModel?.hasState(5 )) {
-                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 };