@codingame/monaco-vscode-api 1.79.0 → 1.79.1

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

@@ -0,0 +1,116 @@
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { isEditorInput, isEditorInputWithOptions } from '../../../common/editor.js';
+import { IEditorGroupsService, preferredSideBySideGroupDirection } from './editorGroupsService.js';
+import { SIDE_GROUP } from './editorService.js';
+function findGroup(accessor, editor, preferredGroup) {
+    const editorGroupService = accessor.get(IEditorGroupsService);
+    const configurationService = accessor.get(IConfigurationService);
+    const group = doFindGroup(editor, preferredGroup, editorGroupService, configurationService);
+    let activation = undefined;
+    if (editorGroupService.activeGroup !== group &&
+        editor.options && !editor.options.inactive &&
+        editor.options.preserveFocus &&
+        typeof editor.options.activation !== 'number' &&
+        preferredGroup !== SIDE_GROUP
+    ) {
+        activation = EditorActivation.ACTIVATE;
+    }
+    return [group, activation];
+}
+function doFindGroup(input, preferredGroup, editorGroupService, configurationService) {
+    let group;
+    const editor = isEditorInputWithOptions(input) ? input.editor : input;
+    const options = input.options;
+    if (preferredGroup && typeof preferredGroup !== 'number') {
+        group = preferredGroup;
+    }
+    else if (typeof preferredGroup === 'number' && preferredGroup >= 0) {
+        group = editorGroupService.getGroup(preferredGroup);
+    }
+    else if (preferredGroup === SIDE_GROUP) {
+        const direction = preferredSideBySideGroupDirection(configurationService);
+        let candidateGroup = editorGroupService.findGroup({ direction });
+        if (!candidateGroup || isGroupLockedForEditor(candidateGroup, editor)) {
+            candidateGroup = editorGroupService.addGroup(editorGroupService.activeGroup, direction);
+        }
+        group = candidateGroup;
+    }
+    else if (!options || typeof options.index !== 'number') {
+        const groupsByLastActive = editorGroupService.getGroups(1 );
+        if (options?.revealIfVisible) {
+            for (const lastActiveGroup of groupsByLastActive) {
+                if (isActive(lastActiveGroup, editor)) {
+                    group = lastActiveGroup;
+                    break;
+                }
+            }
+        }
+        if (!group) {
+            if (options?.revealIfOpened || configurationService.getValue('workbench.editor.revealIfOpen') || (isEditorInput(editor) && editor.hasCapability(8 ))) {
+                let groupWithInputActive = undefined;
+                let groupWithInputOpened = undefined;
+                for (const group of groupsByLastActive) {
+                    if (isOpened(group, editor)) {
+                        if (!groupWithInputOpened) {
+                            groupWithInputOpened = group;
+                        }
+                        if (!groupWithInputActive && group.isActive(editor)) {
+                            groupWithInputActive = group;
+                        }
+                    }
+                    if (groupWithInputOpened && groupWithInputActive) {
+                        break;
+                    }
+                }
+                group = groupWithInputActive || groupWithInputOpened;
+            }
+        }
+    }
+    if (!group) {
+        let candidateGroup = editorGroupService.activeGroup;
+        if (isGroupLockedForEditor(candidateGroup, editor)) {
+            for (const group of editorGroupService.getGroups(1 )) {
+                if (isGroupLockedForEditor(group, editor)) {
+                    continue;
+                }
+                candidateGroup = group;
+                break;
+            }
+            if (isGroupLockedForEditor(candidateGroup, editor)) {
+                group = editorGroupService.addGroup(candidateGroup, preferredSideBySideGroupDirection(configurationService));
+            }
+            else {
+                group = candidateGroup;
+            }
+        }
+        else {
+            group = candidateGroup;
+        }
+    }
+    return group;
+}
+function isGroupLockedForEditor(group, editor) {
+    if (!group.isLocked) {
+        return false;
+    }
+    if (isOpened(group, editor)) {
+        return false;
+    }
+    return true;
+}
+function isActive(group, editor) {
+    if (!group.activeEditor) {
+        return false;
+    }
+    return group.activeEditor.matches(editor);
+}
+function isOpened(group, editor) {
+    for (const typedEditor of group.editors) {
+        if (typedEditor.matches(editor)) {
+            return true;
+        }
+    }
+    return false;
+}
+export { findGroup };

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

@@ -1,5 +1,10 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { isEditorInput } from '../../../common/editor.js';
 const IEditorGroupsService = ( createDecorator('editorGroupsService'));
+function isEditorReplacement(replacement) {
+    const candidate = replacement;
+    return isEditorInput(candidate?.editor) && isEditorInput(candidate?.replacement);
+}
 function isEditorGroup(obj) {
     const group = obj;
     return !!group && typeof group.id === 'number' && Array.isArray(group.editors);
@@ -11,4 +16,4 @@ function preferredSideBySideGroupDirection(configurationService) {
     }
     return 3 ;
 }
-export { IEditorGroupsService, isEditorGroup, preferredSideBySideGroupDirection };
+export { IEditorGroupsService, isEditorGroup, isEditorReplacement, preferredSideBySideGroupDirection };

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

@@ -1,9 +1,14 @@
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 const IEditorResolverService = ( createDecorator('editorResolverService'));
+const editorsAssociationsSettingId = 'workbench.editorAssociations';
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
 const editorAssociationsConfigurationNode = {
     ...workbenchConfigurationNodeBase,
@@ -28,4 +33,32 @@ var RegisteredEditorPriority;
     RegisteredEditorPriority["exclusive"] = "exclusive";
     RegisteredEditorPriority["default"] = "default";
 })(RegisteredEditorPriority || (RegisteredEditorPriority = {})));
-export { IEditorResolverService, RegisteredEditorPriority };
+function priorityToRank(priority) {
+    switch (priority) {
+        case RegisteredEditorPriority.exclusive:
+            return 5;
+        case RegisteredEditorPriority.default:
+            return 4;
+        case RegisteredEditorPriority.builtin:
+            return 3;
+        case RegisteredEditorPriority.option:
+        default:
+            return 1;
+    }
+}
+function globMatchesResource(globPattern, resource) {
+    const excludedSchemes = ( new Set([
+        Schemas.extension,
+        Schemas.webviewPanel,
+        Schemas.vscodeWorkspaceTrust,
+        Schemas.walkThrough,
+        Schemas.vscodeSettings
+    ]));
+    if (( excludedSchemes.has(resource.scheme))) {
+        return false;
+    }
+    const matchOnPath = typeof globPattern === 'string' && globPattern.indexOf(posix.sep) >= 0;
+    const target = matchOnPath ? `${resource.scheme}:${resource.path}` : basename(resource);
+    return glob.match(typeof globPattern === 'string' ? globPattern.toLowerCase() : globPattern, target.toLowerCase());
+}
+export { IEditorResolverService, RegisteredEditorPriority, editorsAssociationsSettingId, globMatchesResource, priorityToRank };