@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/common/editor/resourceEditorInput.js

@@ -3,11 +3,12 @@ import { EditorInput } from './editorInput.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 import { isEqual, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IFilesConfigurationService } from '../../services/filesConfiguration/common/filesConfigurationService.js';
 let AbstractResourceEditorInput = class AbstractResourceEditorInput extends EditorInput {
     get capabilities() {
         let capabilities = 32 ;
         if (this.fileService.hasProvider(this.resource)) {
-            if (this.fileService.hasCapability(this.resource, 2048 )) {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
                 capabilities |= 2 ;
             }
         }
@@ -20,11 +21,12 @@ let AbstractResourceEditorInput = class AbstractResourceEditorInput extends Edit
         return capabilities;
     }
     get preferredResource() { return this._preferredResource; }
-    constructor(resource, preferredResource, labelService, fileService) {
+    constructor(resource, preferredResource, labelService, fileService, filesConfigurationService) {
         super();
         this.resource = resource;
         this.labelService = labelService;
         this.fileService = fileService;
+        this.filesConfigurationService = filesConfigurationService;
         this._name = undefined;
         this._shortDescription = undefined;
         this._mediumDescription = undefined;
@@ -128,6 +130,7 @@ let AbstractResourceEditorInput = class AbstractResourceEditorInput extends Edit
 };
 AbstractResourceEditorInput = ( __decorate([
     ( __param(2, ILabelService)),
-    ( __param(3, IFileService))
+    ( __param(3, IFileService)),
+    ( __param(4, IFilesConfigurationService))
 ], AbstractResourceEditorInput));
 export { AbstractResourceEditorInput };

package/dist/vscode/vs/workbench/common/editor/textResourceEditorInput.js

@@ -10,9 +10,10 @@ import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { TextResourceEditorModel } from './textResourceEditorModel.js';
 import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { IFilesConfigurationService } from '../../services/filesConfiguration/common/filesConfigurationService.js';
 let AbstractTextResourceEditorInput = class AbstractTextResourceEditorInput extends AbstractResourceEditorInput {
-    constructor(resource, preferredResource, editorService, textFileService, labelService, fileService) {
-        super(resource, preferredResource, labelService, fileService);
+    constructor(resource, preferredResource, editorService, textFileService, labelService, fileService, filesConfigurationService) {
+        super(resource, preferredResource, labelService, fileService, filesConfigurationService);
         this.editorService = editorService;
         this.textFileService = textFileService;
     }
@@ -46,7 +47,8 @@ AbstractTextResourceEditorInput = ( __decorate([
     ( __param(2, IEditorService)),
     ( __param(3, ITextFileService)),
     ( __param(4, ILabelService)),
-    ( __param(5, IFileService))
+    ( __param(5, IFileService)),
+    ( __param(6, IFilesConfigurationService))
 ], AbstractTextResourceEditorInput));
 let TextResourceEditorInput = class TextResourceEditorInput extends AbstractTextResourceEditorInput {
     get typeId() {
@@ -55,8 +57,8 @@ let TextResourceEditorInput = class TextResourceEditorInput extends AbstractText
     get editorId() {
         return DEFAULT_EDITOR_ASSOCIATION.id;
     }
-    constructor(resource, name, description, preferredLanguageId, preferredContents, textModelResolverService, textFileService, editorService, fileService, labelService) {
-        super(resource, undefined, editorService, textFileService, labelService, fileService);
+    constructor(resource, name, description, preferredLanguageId, preferredContents, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService) {
+        super(resource, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
         this.name = name;
         this.description = description;
         this.preferredLanguageId = preferredLanguageId;
@@ -141,6 +143,7 @@ TextResourceEditorInput = ( __decorate([
     ( __param(6, ITextFileService)),
     ( __param(7, IEditorService)),
     ( __param(8, IFileService)),
-    ( __param(9, ILabelService))
+    ( __param(9, ILabelService)),
+    ( __param(10, IFilesConfigurationService))
 ], TextResourceEditorInput));
 export { AbstractTextResourceEditorInput, TextResourceEditorInput };

package/dist/vscode/vs/workbench/common/editor.js

@@ -5,6 +5,9 @@ import { toDisposable, Disposable } from 'monaco-editor/esm/vs/base/common/lifec
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isErrorWithActions, createErrorWithActions } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 const EditorExtensions = {
     EditorPane: 'workbench.contributions.editors',
     EditorFactory: 'workbench.contributions.editor.inputFactories'
@@ -14,8 +17,13 @@ const DEFAULT_EDITOR_ASSOCIATION = {
     displayName: ( localize('promptOpenWith.defaultEditor.displayName', "Text Editor")),
     providerDisplayName: ( localize('builtinProviderDisplayName', "Built-in"))
 };
+const SIDE_BY_SIDE_EDITOR_ID = 'workbench.editor.sidebysideEditor';
 const TEXT_DIFF_EDITOR_ID = 'workbench.editors.textDiffEditor';
 const BINARY_DIFF_EDITOR_ID = 'workbench.editors.binaryResourceDiffEditor';
+function isEditorPaneWithSelection(editorPane) {
+    const candidate = editorPane;
+    return !!candidate && typeof candidate.getSelection === 'function' && !!candidate.onDidChangeSelection;
+}
 function findViewStateForEditor(input, group, editorService) {
     for (const editorPane of editorService.visibleEditorPanes) {
         if (editorPane.group.id === group && input.matches(editorPane.input)) {
@@ -58,10 +66,6 @@ function isUntitledResourceEditorInput(editor) {
     }
     return candidate.resource === undefined || candidate.resource.scheme === Schemas.untitled || candidate.forceUntitled === true;
 }
-const UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/;
-function isUntitledWithAssociatedResource(resource) {
-    return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
-}
 function isResourceMergeEditorInput(editor) {
     if (isEditorInput(editor)) {
         return false;
@@ -103,10 +107,48 @@ function isDiffEditorInput(editor) {
     const candidate = editor;
     return isEditorInput(candidate?.modified) && isEditorInput(candidate?.original);
 }
+function createTooLargeFileError(group, input, options, message, preferencesService) {
+    return createEditorOpenError(message, [
+        toAction({
+            id: 'workbench.action.openLargeFile', label: ( localize('openLargeFile', "Open Anyway")), run: () => {
+                const fileEditorOptions = {
+                    ...options,
+                    limits: {
+                        size: Number.MAX_VALUE
+                    }
+                };
+                group.openEditor(input, fileEditorOptions);
+            }
+        }),
+        toAction({
+            id: 'workbench.action.configureEditorLargeFileConfirmation', label: ( localize('configureEditorLargeFileConfirmation', "Configure Limit")), run: () => {
+                return preferencesService.openUserSettings({ query: 'workbench.editorLargeFileConfirmation' });
+            }
+        }),
+    ], {
+        forceMessage: true,
+        forceSeverity: Severity.Warning
+    });
+}
+function isEditorInputWithOptions(editor) {
+    const candidate = editor;
+    return isEditorInput(candidate?.editor);
+}
+function isEditorInputWithOptionsAndGroup(editor) {
+    const candidate = editor;
+    return isEditorInputWithOptions(editor) && candidate?.group !== undefined;
+}
 function isEditorIdentifier(identifier) {
     const candidate = identifier;
     return typeof candidate?.groupId === 'number' && isEditorInput(candidate.editor);
 }
+var EditorCloseContext;
+( (function(EditorCloseContext) {
+    EditorCloseContext[EditorCloseContext["UNKNOWN"] = 0] = "UNKNOWN";
+    EditorCloseContext[EditorCloseContext["REPLACE"] = 1] = "REPLACE";
+    EditorCloseContext[EditorCloseContext["MOVE"] = 2] = "MOVE";
+    EditorCloseContext[EditorCloseContext["UNPIN"] = 3] = "UNPIN";
+})(EditorCloseContext || (EditorCloseContext = {})));
 var SideBySideEditor;
 ( (function(SideBySideEditor) {
     SideBySideEditor[SideBySideEditor["PRIMARY"] = 1] = "PRIMARY";
@@ -258,4 +300,14 @@ function isTextEditorViewState(candidate) {
     const codeEditorViewState = viewState;
     return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));
 }
-export { AbstractEditorInput, BINARY_DIFF_EDITOR_ID, DEFAULT_EDITOR_ASSOCIATION, EditorExtensions, EditorResourceAccessor, SaveSourceRegistry, SideBySideEditor, TEXT_DIFF_EDITOR_ID, findViewStateForEditor, isDiffEditorInput, isEditorIdentifier, isEditorInput, isResourceDiffEditorInput, isResourceEditorInput, isResourceMergeEditorInput, isResourceSideBySideEditorInput, isSideBySideEditorInput, isTextEditorViewState, isUntitledResourceEditorInput, isUntitledWithAssociatedResource };
+function isEditorOpenError(obj) {
+    return isErrorWithActions(obj);
+}
+function createEditorOpenError(messageOrError, actions, options) {
+    const error = createErrorWithActions(messageOrError, actions);
+    error.forceMessage = options?.forceMessage;
+    error.forceSeverity = options?.forceSeverity;
+    error.allowDialog = options?.allowDialog;
+    return error;
+}
+export { AbstractEditorInput, BINARY_DIFF_EDITOR_ID, DEFAULT_EDITOR_ASSOCIATION, EditorCloseContext, EditorExtensions, EditorResourceAccessor, SIDE_BY_SIDE_EDITOR_ID, SaveSourceRegistry, SideBySideEditor, TEXT_DIFF_EDITOR_ID, createEditorOpenError, createTooLargeFileError, findViewStateForEditor, isDiffEditorInput, isEditorIdentifier, isEditorInput, isEditorInputWithOptions, isEditorInputWithOptionsAndGroup, isEditorOpenError, isEditorPaneWithSelection, isResourceDiffEditorInput, isResourceEditorInput, isResourceMergeEditorInput, isResourceSideBySideEditorInput, isSideBySideEditorInput, isTextEditorViewState, isUntitledResourceEditorInput };

package/dist/vscode/vs/workbench/common/resources.js

@@ -1,84 +1,161 @@
 import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { getDriveLetter } from 'monaco-editor/esm/vs/base/common/extpath.js';
 let ResourceGlobMatcher = class ResourceGlobMatcher extends Disposable {
-    constructor(globFn, shouldUpdate, contextService, configurationService) {
+    constructor(getExpression, shouldUpdate, contextService, configurationService) {
         super();
-        this.globFn = globFn;
+        this.getExpression = getExpression;
         this.shouldUpdate = shouldUpdate;
         this.contextService = contextService;
         this.configurationService = configurationService;
         this._onExpressionChange = this._register(( new Emitter()));
         this.onExpressionChange = this._onExpressionChange.event;
-        this.mapRootToParsedExpression = ( new Map());
-        this.mapRootToExpressionConfig = ( new Map());
-        this.updateExcludes(false);
+        this.mapFolderToParsedExpression = ( new Map());
+        this.mapFolderToConfiguredExpression = ( new Map());
+        this.updateExpressions(false);
         this.registerListeners();
     }
     registerListeners() {
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             if (this.shouldUpdate(e)) {
-                this.updateExcludes(true);
+                this.updateExpressions(true);
             }
         }));
-        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExcludes(true)));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExpressions(true)));
     }
-    updateExcludes(fromEvent) {
+    updateExpressions(fromEvent) {
         let changed = false;
-        this.contextService.getWorkspace().folders.forEach(folder => {
-            const rootExcludes = this.globFn(folder.uri);
-            if (!( this.mapRootToExpressionConfig.has(( folder.uri.toString()))) || !equals(this.mapRootToExpressionConfig.get(( folder.uri.toString())), rootExcludes)) {
+        for (const folder of this.contextService.getWorkspace().folders) {
+            const folderUriStr = ( folder.uri.toString());
+            const newExpression = this.doGetExpression(folder.uri);
+            const currentExpression = this.mapFolderToConfiguredExpression.get(folderUriStr);
+            if (newExpression) {
+                if (!currentExpression || !equals(currentExpression.expression, newExpression.expression)) {
+                    changed = true;
+                    this.mapFolderToParsedExpression.set(folderUriStr, parse(newExpression.expression));
+                    this.mapFolderToConfiguredExpression.set(folderUriStr, newExpression);
+                }
+            }
+            else {
+                if (currentExpression) {
+                    changed = true;
+                    this.mapFolderToParsedExpression.delete(folderUriStr);
+                    this.mapFolderToConfiguredExpression.delete(folderUriStr);
+                }
+            }
+        }
+        const foldersMap = ( new ResourceSet(( this.contextService.getWorkspace().folders.map(folder => folder.uri))));
+        for (const [folder] of this.mapFolderToConfiguredExpression) {
+            if (folder === ResourceGlobMatcher.NO_FOLDER) {
+                continue;
+            }
+            if (!( foldersMap.has(( URI.parse(folder))))) {
+                this.mapFolderToParsedExpression.delete(folder);
+                this.mapFolderToConfiguredExpression.delete(folder);
                 changed = true;
-                this.mapRootToParsedExpression.set(( folder.uri.toString()), parse(rootExcludes));
-                this.mapRootToExpressionConfig.set(( folder.uri.toString()), deepClone(rootExcludes));
             }
-        });
-        this.mapRootToExpressionConfig.forEach((value, root) => {
-            if (root === ResourceGlobMatcher.NO_ROOT) {
-                return;
+        }
+        const globalNewExpression = this.doGetExpression(undefined);
+        const globalCurrentExpression = this.mapFolderToConfiguredExpression.get(ResourceGlobMatcher.NO_FOLDER);
+        if (globalNewExpression) {
+            if (!globalCurrentExpression || !equals(globalCurrentExpression.expression, globalNewExpression.expression)) {
+                changed = true;
+                this.mapFolderToParsedExpression.set(ResourceGlobMatcher.NO_FOLDER, parse(globalNewExpression.expression));
+                this.mapFolderToConfiguredExpression.set(ResourceGlobMatcher.NO_FOLDER, globalNewExpression);
             }
-            if (root && !this.contextService.getWorkspaceFolder(( URI.parse(root)))) {
-                this.mapRootToParsedExpression.delete(root);
-                this.mapRootToExpressionConfig.delete(root);
+        }
+        else {
+            if (globalCurrentExpression) {
                 changed = true;
+                this.mapFolderToParsedExpression.delete(ResourceGlobMatcher.NO_FOLDER);
+                this.mapFolderToConfiguredExpression.delete(ResourceGlobMatcher.NO_FOLDER);
             }
-        });
-        const globalExcludes = this.globFn();
-        if (!( this.mapRootToExpressionConfig.has(ResourceGlobMatcher.NO_ROOT)) || !equals(this.mapRootToExpressionConfig.get(ResourceGlobMatcher.NO_ROOT), globalExcludes)) {
-            changed = true;
-            this.mapRootToParsedExpression.set(ResourceGlobMatcher.NO_ROOT, parse(globalExcludes));
-            this.mapRootToExpressionConfig.set(ResourceGlobMatcher.NO_ROOT, deepClone(globalExcludes));
         }
         if (fromEvent && changed) {
             this._onExpressionChange.fire();
         }
     }
+    doGetExpression(resource) {
+        const expression = this.getExpression(resource);
+        if (!expression) {
+            return undefined;
+        }
+        const keys = ( Object.keys(expression));
+        if (keys.length === 0) {
+            return undefined;
+        }
+        let hasAbsolutePath = false;
+        const massagedExpression = Object.create(null);
+        for (const key of keys) {
+            if (!hasAbsolutePath) {
+                hasAbsolutePath = isAbsolute(key);
+            }
+            let massagedKey = key;
+            const driveLetter = getDriveLetter(massagedKey, true );
+            if (driveLetter) {
+                const driveLetterLower = driveLetter.toLowerCase();
+                if (driveLetter !== driveLetter.toLowerCase()) {
+                    massagedKey = `${driveLetterLower}${massagedKey.substring(1)}`;
+                }
+            }
+            massagedExpression[massagedKey] = expression[key];
+        }
+        return {
+            expression: massagedExpression,
+            hasAbsolutePath
+        };
+    }
     matches(resource, hasSibling) {
+        if (this.mapFolderToParsedExpression.size === 0) {
+            return false;
+        }
         const folder = this.contextService.getWorkspaceFolder(resource);
-        let expressionForRoot;
-        if (folder && ( this.mapRootToParsedExpression.has(( folder.uri.toString())))) {
-            expressionForRoot = this.mapRootToParsedExpression.get(( folder.uri.toString()));
+        let expressionForFolder;
+        let expressionConfigForFolder;
+        if (folder && ( this.mapFolderToParsedExpression.has(( folder.uri.toString())))) {
+            expressionForFolder = this.mapFolderToParsedExpression.get(( folder.uri.toString()));
+            expressionConfigForFolder = this.mapFolderToConfiguredExpression.get(( folder.uri.toString()));
         }
         else {
-            expressionForRoot = this.mapRootToParsedExpression.get(ResourceGlobMatcher.NO_ROOT);
+            expressionForFolder = this.mapFolderToParsedExpression.get(ResourceGlobMatcher.NO_FOLDER);
+            expressionConfigForFolder = this.mapFolderToConfiguredExpression.get(ResourceGlobMatcher.NO_FOLDER);
+        }
+        if (!expressionForFolder) {
+            return false;
         }
         let resourcePathToMatch;
         if (folder) {
             resourcePathToMatch = relativePath(folder.uri, resource);
         }
         else {
-            resourcePathToMatch = resource.fsPath;
+            resourcePathToMatch = this.uriToPath(resource);
+        }
+        if (typeof resourcePathToMatch === 'string' && !!expressionForFolder(resourcePathToMatch, undefined, hasSibling)) {
+            return true;
+        }
+        if (resourcePathToMatch !== this.uriToPath(resource) && expressionConfigForFolder?.hasAbsolutePath) {
+            return !!expressionForFolder(this.uriToPath(resource), undefined, hasSibling);
+        }
+        return false;
+    }
+    uriToPath(uri) {
+        if (uri.scheme === Schemas.file) {
+            return uri.fsPath;
         }
-        return !!expressionForRoot && typeof resourcePathToMatch === 'string' && !!expressionForRoot(resourcePathToMatch, undefined, hasSibling);
+        return uri.path;
     }
 };
-ResourceGlobMatcher.NO_ROOT = null;
+ResourceGlobMatcher.NO_FOLDER = null;
 ResourceGlobMatcher = ( __decorate([
     ( __param(2, IWorkspaceContextService)),
     ( __param(3, IConfigurationService))