@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

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

@@ -1,17 +1,15 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { Extensions } from '../../../common/contributions.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.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 { UndoCommand, RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { 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';
@@ -25,8 +23,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
         return obj instanceof FileEditorInput;
     }
 });
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExplorerViewletViewsContribution, 1 );
-const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
 const hotExitConfiguration = isNative ?
     {
         'type': 'string',
@@ -374,368 +371,6 @@ 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,90 +1,3 @@
-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'));
-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 };
+export { IExplorerService };