@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/files/browser/files.contribution.js

@@ -1,15 +1,17 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions } from '../../../common/contributions.js';
 import { EditorExtensions } from '../../../common/editor.js';
 import { FILES_EXCLUDE_CONFIG, FILES_ASSOCIATIONS_CONFIG, AutoSaveConfiguration, HotExitConfiguration } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { FILE_EDITOR_INPUT_ID, BINARY_TEXT_FILE_MODE } from '../common/files.js';
 import { FileEditorInput } from './editors/fileEditorInput.js';
 import { isWeb, isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { ExplorerViewletViewsContribution } from './explorerViewlet.js';
 import { UNDO_REDO_SOURCE } from './explorerService.js';
 import { SUPPORTED_ENCODINGS } from '../../../services/textfile/common/encoding.js';
 import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
-import { RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { UndoCommand, RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
 import { IExplorerService } from './files.js';
 import { ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
@@ -23,7 +25,8 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
         return obj instanceof FileEditorInput;
     }
 });
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExplorerViewletViewsContribution, 1 );
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
 const hotExitConfiguration = isNative ?
     {
         'type': 'string',
@@ -271,16 +274,6 @@ configurationRegistry.registerConfiguration({
                 "The default language identifier that is assigned to new files. If configured to `${activeEditorLanguage}`, will use the language identifier of the currently active text editor if any."
             ))
         },
-        'files.maxMemoryForLargeFilesMB': {
-            'type': 'number',
-            'default': 4096,
-            'minimum': 0,
-            'markdownDescription': ( nls.localize(
-                'maxMemoryForLargeFilesMB',
-                "Controls the memory available to VS Code after restart when trying to open large files. Same effect as specifying `--max-memory=NEWSIZE` on the command line."
-            )),
-            included: isNative
-        },
         'files.restoreUndoStack': {
             'type': 'boolean',
             'description': ( nls.localize(
@@ -371,6 +364,368 @@ configurationRegistry.registerConfiguration({
         },
     }
 });
+configurationRegistry.registerConfiguration({
+    'id': 'explorer',
+    'order': 10,
+    'title': ( nls.localize('explorerConfigurationTitle', "File Explorer")),
+    'type': 'object',
+    'properties': {
+        'explorer.openEditors.visible': {
+            'type': 'number',
+            'description': ( nls.localize(
+                { key: 'openEditorsVisible', comment: ['Open is an adjective'] },
+                "The maximum number of editors shown in the Open Editors pane. Setting this to 0 hides the Open Editors pane."
+            )),
+            'default': 9,
+            'minimum': 0
+        },
+        'explorer.openEditors.minVisible': {
+            'type': 'number',
+            'description': ( nls.localize(
+                { key: 'openEditorsVisibleMin', comment: ['Open is an adjective'] },
+                "The minimum number of editor slots shown in the Open Editors pane. If set to 0 the Open Editors pane will dynamically resize based on the number of editors."
+            )),
+            'default': 0,
+            'minimum': 0
+        },
+        'explorer.openEditors.sortOrder': {
+            'type': 'string',
+            'enum': ['editorOrder', 'alphabetical', 'fullPath'],
+            'description': ( nls.localize(
+                { key: 'openEditorsSortOrder', comment: ['Open is an adjective'] },
+                "Controls the sorting order of editors in the Open Editors pane."
+            )),
+            'enumDescriptions': [
+                ( nls.localize(
+                    'sortOrder.editorOrder',
+                    'Editors are ordered in the same order editor tabs are shown.'
+                )),
+                ( nls.localize(
+                    'sortOrder.alphabetical',
+                    'Editors are ordered alphabetically by tab name inside each editor group.'
+                )),
+                ( nls.localize(
+                    'sortOrder.fullPath',
+                    'Editors are ordered alphabetically by full path inside each editor group.'
+                ))
+            ],
+            'default': 'editorOrder'
+        },
+        'explorer.autoReveal': {
+            'type': ['boolean', 'string'],
+            'enum': [true, false, 'focusNoScroll'],
+            'default': true,
+            'enumDescriptions': [
+                ( nls.localize('autoReveal.on', 'Files will be revealed and selected.')),
+                ( nls.localize('autoReveal.off', 'Files will not be revealed and selected.')),
+                ( nls.localize(
+                    'autoReveal.focusNoScroll',
+                    'Files will not be scrolled into view, but will still be focused.'
+                )),
+            ],
+            'description': ( nls.localize(
+                'autoReveal',
+                "Controls whether the Explorer should automatically reveal and select files when opening them."
+            ))
+        },
+        'explorer.autoRevealExclude': {
+            'type': 'object',
+            'markdownDescription': ( nls.localize(
+                'autoRevealExclude',
+                "Configure glob patterns for excluding files and folders from being revealed and selected in the Explorer when they are opened. Read more about glob patterns [here](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options)."
+            )),
+            'default': { '**/node_modules': true, '**/bower_components': true },
+            'additionalProperties': {
+                'anyOf': [
+                    {
+                        'type': 'boolean',
+                        'description': ( nls.localize(
+                            'explorer.autoRevealExclude.boolean',
+                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
+                        )),
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            when: {
+                                type: 'string',
+                                pattern: '\\w*\\$\\(basename\\)\\w*',
+                                default: '$(basename).ext',
+                                description: ( nls.localize(
+                                    'explorer.autoRevealExclude.when',
+                                    'Additional check on the siblings of a matching file. Use $(basename) as variable for the matching file name.'
+                                ))
+                            }
+                        }
+                    }
+                ]
+            }
+        },
+        'explorer.enableDragAndDrop': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'enableDragAndDrop',
+                "Controls whether the Explorer should allow to move files and folders via drag and drop. This setting only effects drag and drop from inside the Explorer."
+            )),
+            'default': true
+        },
+        'explorer.confirmDragAndDrop': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'confirmDragAndDrop',
+                "Controls whether the Explorer should ask for confirmation to move files and folders via drag and drop."
+            )),
+            'default': true
+        },
+        'explorer.confirmDelete': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'confirmDelete',
+                "Controls whether the Explorer should ask for confirmation when deleting a file via the trash."
+            )),
+            'default': true
+        },
+        'explorer.enableUndo': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'enableUndo',
+                "Controls whether the Explorer should support undoing file and folder operations."
+            )),
+            'default': true
+        },
+        'explorer.confirmUndo': {
+            'type': 'string',
+            'enum': ["verbose" , "default" , "light" ],
+            'description': ( nls.localize(
+                'confirmUndo',
+                "Controls whether the Explorer should ask for confirmation when undoing."
+            )),
+            'default': "default" ,
+            'enumDescriptions': [
+                ( nls.localize('enableUndo.verbose', 'Explorer will prompt before all undo operations.')),
+                ( nls.localize(
+                    'enableUndo.default',
+                    'Explorer will prompt before destructive undo operations.'
+                )),
+                ( nls.localize(
+                    'enableUndo.light',
+                    'Explorer will not prompt before undo operations when focused.'
+                )),
+            ],
+        },
+        'explorer.expandSingleFolderWorkspaces': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'expandSingleFolderWorkspaces',
+                "Controls whether the Explorer should expand multi-root workspaces containing only one folder during initialization"
+            )),
+            'default': true
+        },
+        'explorer.sortOrder': {
+            'type': 'string',
+            'enum': ["default" , "mixed" , "filesFirst" , "type" , "modified" , "foldersNestsFiles" ],
+            'default': "default" ,
+            'enumDescriptions': [
+                ( nls.localize(
+                    'sortOrder.default',
+                    'Files and folders are sorted by their names. Folders are displayed before files.'
+                )),
+                ( nls.localize(
+                    'sortOrder.mixed',
+                    'Files and folders are sorted by their names. Files are interwoven with folders.'
+                )),
+                ( nls.localize(
+                    'sortOrder.filesFirst',
+                    'Files and folders are sorted by their names. Files are displayed before folders.'
+                )),
+                ( nls.localize(
+                    'sortOrder.type',
+                    'Files and folders are grouped by extension type then sorted by their names. Folders are displayed before files.'
+                )),
+                ( nls.localize(
+                    'sortOrder.modified',
+                    'Files and folders are sorted by last modified date in descending order. Folders are displayed before files.'
+                )),
+                ( nls.localize(
+                    'sortOrder.foldersNestsFiles',
+                    'Files and folders are sorted by their names. Folders are displayed before files. Files with nested children are displayed before other files.'
+                ))
+            ],
+            'markdownDescription': ( nls.localize(
+                'sortOrder',
+                "Controls the property-based sorting of files and folders in the Explorer. When `#explorer.fileNesting.enabled#` is enabled, also controls sorting of nested files."
+            ))
+        },
+        'explorer.sortOrderLexicographicOptions': {
+            'type': 'string',
+            'enum': ["default" , "upper" , "lower" , "unicode" ],
+            'default': "default" ,
+            'enumDescriptions': [
+                ( nls.localize(
+                    'sortOrderLexicographicOptions.default',
+                    'Uppercase and lowercase names are mixed together.'
+                )),
+                ( nls.localize(
+                    'sortOrderLexicographicOptions.upper',
+                    'Uppercase names are grouped together before lowercase names.'
+                )),
+                ( nls.localize(
+                    'sortOrderLexicographicOptions.lower',
+                    'Lowercase names are grouped together before uppercase names.'
+                )),
+                ( nls.localize(
+                    'sortOrderLexicographicOptions.unicode',
+                    'Names are sorted in Unicode order.'
+                ))
+            ],
+            'description': ( nls.localize(
+                'sortOrderLexicographicOptions',
+                "Controls the lexicographic sorting of file and folder names in the Explorer."
+            ))
+        },
+        'explorer.decorations.colors': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'explorer.decorations.colors',
+                "Controls whether file decorations should use colors."
+            )),
+            default: true
+        },
+        'explorer.decorations.badges': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'explorer.decorations.badges',
+                "Controls whether file decorations should use badges."
+            )),
+            default: true
+        },
+        'explorer.incrementalNaming': {
+            'type': 'string',
+            enum: ['simple', 'smart', 'disabled'],
+            enumDescriptions: [
+                ( nls.localize(
+                    'simple',
+                    "Appends the word \"copy\" at the end of the duplicated name potentially followed by a number."
+                )),
+                ( nls.localize(
+                    'smart',
+                    "Adds a number at the end of the duplicated name. If some number is already part of the name, tries to increase that number."
+                )),
+                ( nls.localize(
+                    'disabled',
+                    "Disables incremental naming. If two files with the same name exist you will be prompted to overwrite the existing file."
+                ))
+            ],
+            description: ( nls.localize(
+                'explorer.incrementalNaming',
+                "Controls what naming strategy to use when a giving a new name to a duplicated Explorer item on paste."
+            )),
+            default: 'simple'
+        },
+        'explorer.compactFolders': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'compressSingleChildFolders',
+                "Controls whether the Explorer should render folders in a compact form. In such a form, single child folders will be compressed in a combined tree element. Useful for Java package structures, for example."
+            )),
+            'default': true
+        },
+        'explorer.copyRelativePathSeparator': {
+            'type': 'string',
+            'enum': [
+                '/',
+                '\\',
+                'auto'
+            ],
+            'enumDescriptions': [
+                ( nls.localize(
+                    'copyRelativePathSeparator.slash',
+                    "Use slash as path separation character."
+                )),
+                ( nls.localize(
+                    'copyRelativePathSeparator.backslash',
+                    "Use backslash as path separation character."
+                )),
+                ( nls.localize(
+                    'copyRelativePathSeparator.auto',
+                    "Uses operating system specific path separation character."
+                )),
+            ],
+            'description': ( nls.localize(
+                'copyRelativePathSeparator',
+                "The path separation character used when copying relative file paths."
+            )),
+            'default': 'auto'
+        },
+        'explorer.excludeGitIgnore': {
+            type: 'boolean',
+            markdownDescription: ( nls.localize(
+                'excludeGitignore',
+                "Controls whether entries in .gitignore should be parsed and excluded from the Explorer. Similar to {0}.",
+                '`#files.exclude#`'
+            )),
+            default: false,
+            scope: 4
+        },
+        'explorer.fileNesting.enabled': {
+            'type': 'boolean',
+            scope: 4 ,
+            'markdownDescription': ( nls.localize(
+                'fileNestingEnabled',
+                "Controls whether file nesting is enabled in the Explorer. File nesting allows for related files in a directory to be visually grouped together under a single parent file."
+            )),
+            'default': false,
+        },
+        'explorer.fileNesting.expand': {
+            'type': 'boolean',
+            'markdownDescription': ( nls.localize(
+                'fileNestingExpand',
+                "Controls whether file nests are automatically expanded. {0} must be set for this to take effect.",
+                '`#explorer.fileNesting.enabled#`'
+            )),
+            'default': true,
+        },
+        'explorer.fileNesting.patterns': {
+            'type': 'object',
+            scope: 4 ,
+            'markdownDescription': ( nls.localize(
+                'fileNestingPatterns',
+                "Controls nesting of files in the Explorer. {0} must be set for this to take effect. Each __Item__ represents a parent pattern and may contain a single `*` character that matches any string. Each __Value__ represents a comma separated list of the child patterns that should be shown nested under a given parent. Child patterns may contain several special tokens:\n- `${capture}`: Matches the resolved value of the `*` from the parent pattern\n- `${basename}`: Matches the parent file's basename, the `file` in `file.ts`\n- `${extname}`: Matches the parent file's extension, the `ts` in `file.ts`\n- `${dirname}`: Matches the parent file's directory name, the `src` in `src/file.ts`\n- `*`:  Matches any string, may only be used once per child pattern",
+                '`#explorer.fileNesting.enabled#`'
+            )),
+            patternProperties: {
+                '^[^*]*\\*?[^*]*$': {
+                    markdownDescription: ( nls.localize(
+                        'fileNesting.description',
+                        "Each key pattern may contain a single `*` character which will match any string."
+                    )),
+                    type: 'string',
+                    pattern: '^([^,*]*\\*?[^,*]*)(, ?[^,*]*\\*?[^,*]*)*$',
+                }
+            },
+            additionalProperties: false,
+            'default': {
+                '*.ts': '${capture}.js',
+                '*.js': '${capture}.js.map, ${capture}.min.js, ${capture}.d.ts',
+                '*.jsx': '${capture}.js',
+                '*.tsx': '${capture}.ts',
+                'tsconfig.json': 'tsconfig.*.json',
+                'package.json': 'package-lock.json, yarn.lock, pnpm-lock.yaml',
+            }
+        }
+    }
+});
+UndoCommand.addImplementation(110, 'explorer', (accessor) => {
+    const undoRedoService = accessor.get(IUndoRedoService);
+    const explorerService = accessor.get(IExplorerService);
+    const configurationService = accessor.get(IConfigurationService);
+    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
+    if (explorerService.hasViewFocus() && undoRedoService.canUndo(UNDO_REDO_SOURCE) && explorerCanUndo) {
+        undoRedoService.undo(UNDO_REDO_SOURCE);
+        return true;
+    }
+    return false;
+});
 RedoCommand.addImplementation(110, 'explorer', (accessor) => {
     const undoRedoService = accessor.get(IUndoRedoService);
     const explorerService = accessor.get(IExplorerService);

package/dist/vscode/vs/workbench/contrib/files/browser/files.js

@@ -1,3 +1,90 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { OpenEditor } from '../common/files.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { List } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
+import { ExplorerItem } from '../common/explorerModel.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { AsyncDataTree } from 'monaco-editor/esm/vs/base/browser/ui/tree/asyncDataTree.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IExplorerService = ( createDecorator('explorerService'));
-export { IExplorerService };
+function getFocus(listService) {
+    const list = listService.lastFocusedList;
+    if (list?.getHTMLElement() === document.activeElement) {
+        let focus;
+        if (list instanceof List) {
+            const focused = list.getFocusedElements();
+            if (focused.length) {
+                focus = focused[0];
+            }
+        }
+        else if (list instanceof AsyncDataTree) {
+            const focused = list.getFocus();
+            if (focused.length) {
+                focus = focused[0];
+            }
+        }
+        return focus;
+    }
+    return undefined;
+}
+function getResourceForCommand(resource, listService, editorService) {
+    if (URI.isUri(resource)) {
+        return resource;
+    }
+    const focus = getFocus(listService);
+    if (focus instanceof ExplorerItem) {
+        return focus.resource;
+    }
+    else if (focus instanceof OpenEditor) {
+        return focus.getResource();
+    }
+    return EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+}
+function getMultiSelectedResources(resource, listService, editorService, explorerService) {
+    const list = listService.lastFocusedList;
+    if (list?.getHTMLElement() === document.activeElement) {
+        if (list instanceof AsyncDataTree && list.getFocus().every(item => item instanceof ExplorerItem)) {
+            const context = explorerService.getContext(true, true);
+            if (context.length) {
+                return ( context.map(c => c.resource));
+            }
+        }
+        if (list instanceof List) {
+            const selection = coalesce(( list.getSelectedElements().filter(s => s instanceof OpenEditor).map((oe) => oe.getResource())));
+            const focusedElements = list.getFocusedElements();
+            const focus = focusedElements.length ? focusedElements[0] : undefined;
+            let mainUriStr = undefined;
+            if (URI.isUri(resource)) {
+                mainUriStr = ( resource.toString());
+            }
+            else if (focus instanceof OpenEditor) {
+                const focusedResource = focus.getResource();
+                mainUriStr = focusedResource ? ( focusedResource.toString()) : undefined;
+            }
+            if (( selection.some(s => ( s.toString()) === mainUriStr))) {
+                return selection;
+            }
+        }
+    }
+    const result = getResourceForCommand(resource, listService, editorService);
+    return !!result ? [result] : [];
+}
+function getOpenEditorsViewMultiSelection(listService, editorGroupService) {
+    const list = listService.lastFocusedList;
+    if (list?.getHTMLElement() === document.activeElement) {
+        if (list instanceof List) {
+            const selection = coalesce(list.getSelectedElements().filter(s => s instanceof OpenEditor));
+            const focusedElements = list.getFocusedElements();
+            const focus = focusedElements.length ? focusedElements[0] : undefined;
+            let mainEditor = undefined;
+            if (focus instanceof OpenEditor) {
+                mainEditor = focus;
+            }
+            if (( selection.some(s => s === mainEditor))) {
+                return selection;
+            }
+        }
+    }
+    return undefined;
+}
+export { IExplorerService, getMultiSelectedResources, getOpenEditorsViewMultiSelection, getResourceForCommand };

package/dist/vscode/vs/workbench/contrib/files/browser/views/emptyView.js

@@ -0,0 +1,88 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.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 { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { isTemporaryWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ViewPane } from '../../../../browser/parts/views/viewPane.js';
+import { ResourcesDropHandler } from '../../../../browser/dnd.js';
+import { listDropBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IViewDescriptorService } from '../../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { DragAndDropObserver } from 'monaco-editor/esm/vs/base/browser/dom.js';
+let EmptyView = class EmptyView extends ViewPane {
+    constructor(options, themeService, viewDescriptorService, instantiationService, keybindingService, contextMenuService, contextService, configurationService, labelService, contextKeyService, openerService, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.contextService = contextService;
+        this.labelService = labelService;
+        this._disposed = false;
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.refreshTitle()));
+        this._register(this.labelService.onDidChangeFormatters(() => this.refreshTitle()));
+    }
+    shouldShowWelcome() {
+        return true;
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this._register(( new DragAndDropObserver(container, {
+            onDrop: e => {
+                container.style.backgroundColor = '';
+                const dropHandler = this.instantiationService.createInstance(ResourcesDropHandler, { allowWorkspaceOpen: !isWeb || isTemporaryWorkspace(this.contextService.getWorkspace()) });
+                dropHandler.handleDrop(e, () => undefined, () => undefined);
+            },
+            onDragEnter: () => {
+                const color = this.themeService.getColorTheme().getColor(listDropBackground);
+                container.style.backgroundColor = color ? ( color.toString()) : '';
+            },
+            onDragEnd: () => {
+                container.style.backgroundColor = '';
+            },
+            onDragLeave: () => {
+                container.style.backgroundColor = '';
+            },
+            onDragOver: e => {
+                if (e.dataTransfer) {
+                    e.dataTransfer.dropEffect = 'copy';
+                }
+            }
+        })));
+        this.refreshTitle();
+    }
+    refreshTitle() {
+        if (this._disposed) {
+            return;
+        }
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            this.updateTitle(EmptyView.NAME);
+        }
+        else {
+            this.updateTitle(this.title);
+        }
+    }
+    dispose() {
+        this._disposed = true;
+        super.dispose();
+    }
+};
+EmptyView.ID = 'workbench.explorer.emptyView';
+EmptyView.NAME = ( nls.localize('noWorkspace', "No Folder Opened"));
+EmptyView = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, ILabelService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, ITelemetryService))
+], EmptyView));
+export { EmptyView };

package/dist/vscode/vs/workbench/contrib/files/browser/views/explorerDecorationsProvider.js

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { listInvalidItemForeground, listDeemphasizedForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { explorerRootErrorEmitter } from './explorerViewer.js';
+import { IExplorerService } from '../files.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+function provideDecorations(fileStat) {
+    if (fileStat.isRoot && fileStat.error) {
+        return {
+            tooltip: ( localize(
+                'canNotResolve',
+                "Unable to resolve workspace folder ({0})",
+                toErrorMessage(fileStat.error)
+            )),
+            letter: '!',
+            color: listInvalidItemForeground,
+        };
+    }
+    if (fileStat.isSymbolicLink) {
+        return {
+            tooltip: ( localize('symbolicLlink', "Symbolic Link")),
+            letter: '\u2937'
+        };
+    }
+    if (fileStat.isUnknown) {
+        return {
+            tooltip: ( localize('unknown', "Unknown File Type")),
+            letter: '?'
+        };
+    }
+    if (fileStat.isExcluded) {
+        return {
+            color: listDeemphasizedForeground,
+        };
+    }
+    return undefined;
+}
+let ExplorerDecorationsProvider = class ExplorerDecorationsProvider {
+    constructor(explorerService, contextService) {
+        this.explorerService = explorerService;
+        this.label = ( localize('label', "Explorer"));
+        this._onDidChange = ( new Emitter());
+        this.toDispose = ( new DisposableStore());
+        this.toDispose.add(this._onDidChange);
+        this.toDispose.add(contextService.onDidChangeWorkspaceFolders(e => {
+            this._onDidChange.fire(( e.changed.concat(e.added).map(wf => wf.uri)));
+        }));
+        this.toDispose.add(explorerRootErrorEmitter.event((resource => {
+            this._onDidChange.fire([resource]);
+        })));
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    async provideDecorations(resource) {
+        const fileStat = this.explorerService.findClosest(resource);
+        if (!fileStat) {
+            throw new Error('ExplorerItem not found');
+        }
+        return provideDecorations(fileStat);
+    }
+    dispose() {
+        this.toDispose.dispose();
+    }
+};
+ExplorerDecorationsProvider = ( __decorate([
+    ( __param(0, IExplorerService)),
+    ( __param(1, IWorkspaceContextService))
+], ExplorerDecorationsProvider));
+export { ExplorerDecorationsProvider, provideDecorations };