@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryTracker.js

@@ -1,162 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { Limiter, GlobalIdleValue } from '../../../../base/common/async.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { ResourceMap } from '../../../../base/common/map.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IUndoRedoService } from '../../../../platform/undoRedo/common/undoRedo.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { SaveSourceRegistry } from '../../../common/editor.js';
-import { IPathService } from '../../path/common/pathService.js';
-import { isStoredFileWorkingCopySaveEvent } from './storedFileWorkingCopy.js';
-import { MAX_PARALLEL_HISTORY_IO_OPS, IWorkingCopyHistoryService } from './workingCopyHistory.js';
-import { IWorkingCopyService } from './workingCopyService.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { ResourceGlobMatcher } from '../../../common/resources.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-var WorkingCopyHistoryTracker_1;
-let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposable {
-    static { WorkingCopyHistoryTracker_1 = this; }
-    static { this.SETTINGS = {
-        ENABLED: 'workbench.localHistory.enabled',
-        SIZE_LIMIT: 'workbench.localHistory.maxFileSize',
-        EXCLUDES: 'workbench.localHistory.exclude'
-    }; }
-    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryTracker',
-        'undoRedo.source',
-        "Undo / Redo"
-    ))); }
-    constructor(workingCopyService, workingCopyHistoryService, uriIdentityService, pathService, configurationService, undoRedoService, contextService, fileService) {
-        super();
-        this.workingCopyService = workingCopyService;
-        this.workingCopyHistoryService = workingCopyHistoryService;
-        this.uriIdentityService = uriIdentityService;
-        this.pathService = pathService;
-        this.configurationService = configurationService;
-        this.undoRedoService = undoRedoService;
-        this.contextService = contextService;
-        this.fileService = fileService;
-        this.limiter = this._register(( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
-        this.resourceExcludeMatcher = this._register(( new GlobalIdleValue(() => {
-            const matcher = this._register(( new ResourceGlobMatcher(
-                root => this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES, { resource: root }),
-                event => event.affectsConfiguration(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES),
-                this.contextService,
-                this.configurationService
-            )));
-            return matcher;
-        })));
-        this.pendingAddHistoryEntryOperations = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
-        this.workingCopyContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
-        this.historyEntryContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.fileService.onDidRunOperation(e => this.onDidRunFileOperation(e)));
-        this._register(this.workingCopyService.onDidChangeContent(workingCopy => this.onDidChangeContent(workingCopy)));
-        this._register(this.workingCopyService.onDidSave(e => this.onDidSave(e)));
-    }
-    async onDidRunFileOperation(e) {
-        if (!this.shouldTrackHistoryFromFileOperationEvent(e)) {
-            return;
-        }
-        const source = e.resource;
-        const target = e.target.resource;
-        const resources = await this.workingCopyHistoryService.moveEntries(source, target);
-        for (const resource of resources) {
-            const contentVersion = this.getContentVersion(resource);
-            this.historyEntryContentVersion.set(resource, contentVersion);
-        }
-    }
-    onDidChangeContent(workingCopy) {
-        const contentVersionId = this.getContentVersion(workingCopy.resource);
-        this.workingCopyContentVersion.set(workingCopy.resource, contentVersionId + 1);
-    }
-    getContentVersion(resource) {
-        return this.workingCopyContentVersion.get(resource) || 0;
-    }
-    onDidSave(e) {
-        if (!this.shouldTrackHistoryFromSaveEvent(e)) {
-            return;
-        }
-        const contentVersion = this.getContentVersion(e.workingCopy.resource);
-        if (this.historyEntryContentVersion.get(e.workingCopy.resource) === contentVersion) {
-            return;
-        }
-        this.pendingAddHistoryEntryOperations.get(e.workingCopy.resource)?.dispose(true);
-        const cts = ( new CancellationTokenSource());
-        this.pendingAddHistoryEntryOperations.set(e.workingCopy.resource, cts);
-        this.limiter.queue(async () => {
-            if (cts.token.isCancellationRequested) {
-                return;
-            }
-            const contentVersion = this.getContentVersion(e.workingCopy.resource);
-            let source = e.source;
-            if (!e.source) {
-                source = this.resolveSourceFromUndoRedo(e);
-            }
-            await this.workingCopyHistoryService.addEntry({ resource: e.workingCopy.resource, source, timestamp: e.stat.mtime }, cts.token);
-            this.historyEntryContentVersion.set(e.workingCopy.resource, contentVersion);
-            if (cts.token.isCancellationRequested) {
-                return;
-            }
-            this.pendingAddHistoryEntryOperations.delete(e.workingCopy.resource);
-        });
-    }
-    resolveSourceFromUndoRedo(e) {
-        const lastStackElement = this.undoRedoService.getLastElement(e.workingCopy.resource);
-        if (lastStackElement) {
-            if (lastStackElement.code === 'undoredo.textBufferEdit') {
-                return undefined;
-            }
-            return lastStackElement.label;
-        }
-        const allStackElements = this.undoRedoService.getElements(e.workingCopy.resource);
-        if (allStackElements.future.length > 0 || allStackElements.past.length > 0) {
-            return WorkingCopyHistoryTracker_1.UNDO_REDO_SAVE_SOURCE;
-        }
-        return undefined;
-    }
-    shouldTrackHistoryFromSaveEvent(e) {
-        if (!isStoredFileWorkingCopySaveEvent(e)) {
-            return false;
-        }
-        return this.shouldTrackHistory(e.workingCopy.resource, e.stat);
-    }
-    shouldTrackHistoryFromFileOperationEvent(e) {
-        if (!e.isOperation(2 )) {
-            return false;
-        }
-        return this.shouldTrackHistory(e.target.resource, e.target);
-    }
-    shouldTrackHistory(resource, stat) {
-        if (resource.scheme !== this.pathService.defaultUriScheme &&
-            resource.scheme !== Schemas.vscodeUserData &&
-            resource.scheme !== Schemas.inMemory
-        ) {
-            return false;
-        }
-        const configuredMaxFileSizeInBytes = 1024 * this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.SIZE_LIMIT, { resource });
-        if (stat.size > configuredMaxFileSizeInBytes) {
-            return false;
-        }
-        if (this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.ENABLED, { resource }) === false) {
-            return false;
-        }
-        return !this.resourceExcludeMatcher.value.matches(resource);
-    }
-};
-WorkingCopyHistoryTracker = WorkingCopyHistoryTracker_1 = ( __decorate([
-    ( __param(0, IWorkingCopyService)),
-    ( __param(1, IWorkingCopyHistoryService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, IPathService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IUndoRedoService)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IFileService))
-], WorkingCopyHistoryTracker));
-export { WorkingCopyHistoryTracker };

package/vscode/src/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js

@@ -1,335 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { WORKSPACE_FILTER, hasWorkspaceFileExtension, WORKSPACE_EXTENSION, isSavedWorkspace, isUntitledWorkspace, toWorkspaceIdentifier, isWorkspaceIdentifier, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { IJSONEditingService } from '../../configuration/common/jsonEditing.js';
-import { rewriteWorkspaceFileForNewLocation, IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
-import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { firstOrDefault, distinct } from '../../../../base/common/arrays.js';
-import { joinPath, basename, isEqual, removeTrailingPathSeparator } from '../../../../base/common/resources.js';
-import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { mnemonicButtonLabel } from '../../../../base/common/labels.js';
-import { ITextFileService } from '../../textfile/common/textfiles.js';
-import { IHostService } from '../../host/browser/host.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.js';
-import { IWorkbenchConfigurationService } from '../../configuration/common/configuration.js';
-import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
-    constructor(jsonEditingService, contextService, configurationService, notificationService, commandService, fileService, textFileService, workspacesService, environmentService, fileDialogService, dialogService, hostService, uriIdentityService, workspaceTrustManagementService, userDataProfilesService, userDataProfileService) {
-        this.jsonEditingService = jsonEditingService;
-        this.contextService = contextService;
-        this.configurationService = configurationService;
-        this.notificationService = notificationService;
-        this.commandService = commandService;
-        this.fileService = fileService;
-        this.textFileService = textFileService;
-        this.workspacesService = workspacesService;
-        this.environmentService = environmentService;
-        this.fileDialogService = fileDialogService;
-        this.dialogService = dialogService;
-        this.hostService = hostService;
-        this.uriIdentityService = uriIdentityService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.userDataProfileService = userDataProfileService;
-    }
-    async pickNewWorkspacePath() {
-        const availableFileSystems = [Schemas.file];
-        if (this.environmentService.remoteAuthority) {
-            availableFileSystems.unshift(Schemas.vscodeRemote);
-        }
-        let workspacePath = await this.fileDialogService.showSaveDialog({
-            saveLabel: mnemonicButtonLabel(( localizeWithPath(
-                'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                'save',
-                "Save"
-            ))),
-            title: ( localizeWithPath(
-                'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                'saveWorkspace',
-                "Save Workspace"
-            )),
-            filters: WORKSPACE_FILTER,
-            defaultUri: joinPath(await this.fileDialogService.defaultWorkspacePath(), this.getNewWorkspaceName()),
-            availableFileSystems
-        });
-        if (!workspacePath) {
-            return;
-        }
-        if (!hasWorkspaceFileExtension(workspacePath)) {
-            workspacePath = workspacePath.with({ path: `${workspacePath.path}.${WORKSPACE_EXTENSION}` });
-        }
-        return workspacePath;
-    }
-    getNewWorkspaceName() {
-        const configPathURI = this.getCurrentWorkspaceIdentifier()?.configPath;
-        if (configPathURI && isSavedWorkspace(configPathURI, this.environmentService)) {
-            return basename(configPathURI);
-        }
-        const folder = firstOrDefault(this.contextService.getWorkspace().folders);
-        if (folder) {
-            return `${basename(folder.uri)}.${WORKSPACE_EXTENSION}`;
-        }
-        return `workspace.${WORKSPACE_EXTENSION}`;
-    }
-    async updateFolders(index, deleteCount, foldersToAddCandidates, donotNotifyError) {
-        const folders = this.contextService.getWorkspace().folders;
-        let foldersToDelete = [];
-        if (typeof deleteCount === 'number') {
-            foldersToDelete = ( folders.slice(index, index + deleteCount).map(folder => folder.uri));
-        }
-        let foldersToAdd = [];
-        if (Array.isArray(foldersToAddCandidates)) {
-            foldersToAdd = ( foldersToAddCandidates.map(
-                folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
-            ));
-        }
-        const wantsToDelete = foldersToDelete.length > 0;
-        const wantsToAdd = foldersToAdd.length > 0;
-        if (!wantsToAdd && !wantsToDelete) {
-            return;
-        }
-        if (wantsToAdd && !wantsToDelete) {
-            return this.doAddFolders(foldersToAdd, index, donotNotifyError);
-        }
-        if (wantsToDelete && !wantsToAdd) {
-            return this.removeFolders(foldersToDelete);
-        }
-        else {
-            if (this.includesSingleFolderWorkspace(foldersToDelete)) {
-                return this.createAndEnterWorkspace(foldersToAdd);
-            }
-            if (this.contextService.getWorkbenchState() !== 3 ) {
-                return this.doAddFolders(foldersToAdd, index, donotNotifyError);
-            }
-            return this.doUpdateFolders(foldersToAdd, foldersToDelete, index, donotNotifyError);
-        }
-    }
-    async doUpdateFolders(foldersToAdd, foldersToDelete, index, donotNotifyError = false) {
-        try {
-            await this.contextService.updateFolders(foldersToAdd, foldersToDelete, index);
-        }
-        catch (error) {
-            if (donotNotifyError) {
-                throw error;
-            }
-            this.handleWorkspaceConfigurationEditingError(error);
-        }
-    }
-    addFolders(foldersToAddCandidates, donotNotifyError = false) {
-        const foldersToAdd = ( foldersToAddCandidates.map(
-            folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
-        ));
-        return this.doAddFolders(foldersToAdd, undefined, donotNotifyError);
-    }
-    async doAddFolders(foldersToAdd, index, donotNotifyError = false) {
-        const state = this.contextService.getWorkbenchState();
-        if (state !== 3 ) {
-            let newWorkspaceFolders = ( this.contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri })));
-            newWorkspaceFolders.splice(typeof index === 'number' ? index : newWorkspaceFolders.length, 0, ...foldersToAdd);
-            newWorkspaceFolders = distinct(newWorkspaceFolders, folder => this.uriIdentityService.extUri.getComparisonKey(folder.uri));
-            if (state === 1  && newWorkspaceFolders.length === 0 || state === 2  && newWorkspaceFolders.length === 1) {
-                return;
-            }
-            return this.createAndEnterWorkspace(newWorkspaceFolders);
-        }
-        try {
-            await this.contextService.addFolders(foldersToAdd, index);
-        }
-        catch (error) {
-            if (donotNotifyError) {
-                throw error;
-            }
-            this.handleWorkspaceConfigurationEditingError(error);
-        }
-    }
-    async removeFolders(foldersToRemove, donotNotifyError = false) {
-        if (this.includesSingleFolderWorkspace(foldersToRemove)) {
-            return this.createAndEnterWorkspace([]);
-        }
-        try {
-            await this.contextService.removeFolders(foldersToRemove);
-        }
-        catch (error) {
-            if (donotNotifyError) {
-                throw error;
-            }
-            this.handleWorkspaceConfigurationEditingError(error);
-        }
-    }
-    includesSingleFolderWorkspace(folders) {
-        if (this.contextService.getWorkbenchState() === 2 ) {
-            const workspaceFolder = this.contextService.getWorkspace().folders[0];
-            return ( folders.some(
-                folder => this.uriIdentityService.extUri.isEqual(folder, workspaceFolder.uri)
-            ));
-        }
-        return false;
-    }
-    async createAndEnterWorkspace(folders, path) {
-        if (path && !(await this.isValidTargetWorkspacePath(path))) {
-            return;
-        }
-        const remoteAuthority = this.environmentService.remoteAuthority;
-        const untitledWorkspace = await this.workspacesService.createUntitledWorkspace(folders, remoteAuthority);
-        if (path) {
-            try {
-                await this.saveWorkspaceAs(untitledWorkspace, path);
-            }
-            finally {
-                await this.workspacesService.deleteUntitledWorkspace(untitledWorkspace);
-            }
-        }
-        else {
-            path = untitledWorkspace.configPath;
-            if (!this.userDataProfileService.currentProfile.isDefault) {
-                await this.userDataProfilesService.setProfileForWorkspace(untitledWorkspace, this.userDataProfileService.currentProfile);
-            }
-        }
-        return this.enterWorkspace(path);
-    }
-    async saveAndEnterWorkspace(workspaceUri) {
-        const workspaceIdentifier = this.getCurrentWorkspaceIdentifier();
-        if (!workspaceIdentifier) {
-            return;
-        }
-        if (isEqual(workspaceIdentifier.configPath, workspaceUri)) {
-            return this.saveWorkspace(workspaceIdentifier);
-        }
-        if (!(await this.isValidTargetWorkspacePath(workspaceUri))) {
-            return;
-        }
-        await this.saveWorkspaceAs(workspaceIdentifier, workspaceUri);
-        return this.enterWorkspace(workspaceUri);
-    }
-    async isValidTargetWorkspacePath(workspaceUri) {
-        return true;
-    }
-    async saveWorkspaceAs(workspace, targetConfigPathURI) {
-        const configPathURI = workspace.configPath;
-        const isNotUntitledWorkspace = !isUntitledWorkspace(targetConfigPathURI, this.environmentService);
-        if (isNotUntitledWorkspace && !this.userDataProfileService.currentProfile.isDefault) {
-            const newWorkspace = await this.workspacesService.getWorkspaceIdentifier(targetConfigPathURI);
-            await this.userDataProfilesService.setProfileForWorkspace(newWorkspace, this.userDataProfileService.currentProfile);
-        }
-        if (this.uriIdentityService.extUri.isEqual(configPathURI, targetConfigPathURI)) {
-            return;
-        }
-        const isFromUntitledWorkspace = isUntitledWorkspace(configPathURI, this.environmentService);
-        const raw = await this.fileService.readFile(configPathURI);
-        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(( raw.value.toString()), configPathURI, isFromUntitledWorkspace, targetConfigPathURI, this.uriIdentityService.extUri);
-        await this.textFileService.create([{ resource: targetConfigPathURI, value: newRawWorkspaceContents, options: { overwrite: true } }]);
-        await this.trustWorkspaceConfiguration(targetConfigPathURI);
-    }
-    async saveWorkspace(workspace) {
-        const configPathURI = workspace.configPath;
-        const existingModel = this.textFileService.files.get(configPathURI);
-        if (existingModel) {
-            await existingModel.save({ force: true, reason: 1  });
-            return;
-        }
-        const workspaceFileExists = await this.fileService.exists(configPathURI);
-        if (workspaceFileExists) {
-            return;
-        }
-        const newWorkspace = { folders: [] };
-        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(JSON.stringify(newWorkspace, null, '\t'), configPathURI, false, configPathURI, this.uriIdentityService.extUri);
-        await this.textFileService.create([{ resource: configPathURI, value: newRawWorkspaceContents }]);
-    }
-    handleWorkspaceConfigurationEditingError(error) {
-        switch (error.code) {
-            case 0 :
-                this.onInvalidWorkspaceConfigurationFileError();
-                break;
-            default:
-                this.notificationService.error(error.message);
-        }
-    }
-    onInvalidWorkspaceConfigurationFileError() {
-        const message = ( localizeWithPath(
-            'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-            'errorInvalidTaskConfiguration',
-            "Unable to write into workspace configuration file. Please open the file to correct errors/warnings in it and try again."
-        ));
-        this.askToOpenWorkspaceConfigurationFile(message);
-    }
-    askToOpenWorkspaceConfigurationFile(message) {
-        this.notificationService.prompt(Severity.Error, message, [{
-                label: ( localizeWithPath(
-                    'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                    'openWorkspaceConfigurationFile',
-                    "Open Workspace Configuration"
-                )),
-                run: () => this.commandService.executeCommand('workbench.action.openWorkspaceConfigFile')
-            }]);
-    }
-    async doEnterWorkspace(workspaceUri) {
-        if (!!this.environmentService.extensionTestsLocationURI) {
-            throw new Error('Entering a new workspace is not possible in tests.');
-        }
-        const workspace = await this.workspacesService.getWorkspaceIdentifier(workspaceUri);
-        if (this.contextService.getWorkbenchState() === 2 ) {
-            await this.migrateWorkspaceSettings(workspace);
-        }
-        await this.configurationService.initialize(workspace);
-        return this.workspacesService.enterWorkspace(workspaceUri);
-    }
-    migrateWorkspaceSettings(toWorkspace) {
-        return this.doCopyWorkspaceSettings(toWorkspace, setting => setting.scope === 3 );
-    }
-    copyWorkspaceSettings(toWorkspace) {
-        return this.doCopyWorkspaceSettings(toWorkspace);
-    }
-    doCopyWorkspaceSettings(toWorkspace, filter) {
-        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-        const targetWorkspaceConfiguration = {};
-        for (const key of ( this.configurationService.keys()).workspace) {
-            if (configurationProperties[key]) {
-                if (filter && !filter(configurationProperties[key])) {
-                    continue;
-                }
-                targetWorkspaceConfiguration[key] = this.configurationService.inspect(key).workspaceValue;
-            }
-        }
-        return this.jsonEditingService.write(toWorkspace.configPath, [{ path: ['settings'], value: targetWorkspaceConfiguration }], true);
-    }
-    async trustWorkspaceConfiguration(configPathURI) {
-        if (this.contextService.getWorkbenchState() !== 1  && this.workspaceTrustManagementService.isWorkspaceTrusted()) {
-            await this.workspaceTrustManagementService.setUrisTrust([configPathURI], true);
-        }
-    }
-    getCurrentWorkspaceIdentifier() {
-        const identifier = toWorkspaceIdentifier(this.contextService.getWorkspace());
-        if (isWorkspaceIdentifier(identifier)) {
-            return identifier;
-        }
-        return undefined;
-    }
-};
-AbstractWorkspaceEditingService = ( __decorate([
-    ( __param(0, IJSONEditingService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IWorkbenchConfigurationService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, ICommandService)),
-    ( __param(5, IFileService)),
-    ( __param(6, ITextFileService)),
-    ( __param(7, IWorkspacesService)),
-    ( __param(8, IWorkbenchEnvironmentService)),
-    ( __param(9, IFileDialogService)),
-    ( __param(10, IDialogService)),
-    ( __param(11, IHostService)),
-    ( __param(12, IUriIdentityService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IUserDataProfilesService)),
-    ( __param(15, IUserDataProfileService))
-], AbstractWorkspaceEditingService));
-export { AbstractWorkspaceEditingService };

package/vscode/src/vs/workbench/services/workspaces/browser/workspaceTrustEditorInput.js

@@ -1,41 +0,0 @@
-import { Codicon } from '../../../../base/common/codicons.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { URI } from '../../../../base/common/uri.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
-import { EditorInput } from '../../../common/editor/editorInput.js';
-const WorkspaceTrustEditorIcon = registerIcon('workspace-trust-editor-label-icon', Codicon.shield, ( localizeWithPath(
-    'vs/workbench/services/workspaces/browser/workspaceTrustEditorInput',
-    'workspaceTrustEditorLabelIcon',
-    'Icon of the workspace trust editor label.'
-)));
-class WorkspaceTrustEditorInput extends EditorInput {
-    constructor() {
-        super(...arguments);
-        this.resource = ( URI.from({
-            scheme: Schemas.vscodeWorkspaceTrust,
-            path: `workspaceTrustEditor`
-        }));
-    }
-    static { this.ID = 'workbench.input.workspaceTrust'; }
-    get capabilities() {
-        return 2  | 8 ;
-    }
-    get typeId() {
-        return WorkspaceTrustEditorInput.ID;
-    }
-    matches(otherInput) {
-        return super.matches(otherInput) || otherInput instanceof WorkspaceTrustEditorInput;
-    }
-    getName() {
-        return ( localizeWithPath(
-            'vs/workbench/services/workspaces/browser/workspaceTrustEditorInput',
-            'workspaceTrustEditorInputName',
-            "Workspace Trust"
-        ));
-    }
-    getIcon() {
-        return WorkspaceTrustEditorIcon;
-    }
-}
-export { WorkspaceTrustEditorInput };