@codingame/monaco-vscode-base-service-override 7.0.3 → 7.0.7

package/base.js

@@ -26,6 +26,8 @@ import { UserActivityService } from './vscode/src/vs/workbench/services/userActi
 import { WorkingCopyFileService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyFileService.js';
 import { ITrustedDomainService } from 'vscode/vscode/vs/workbench/contrib/url/browser/trustedDomainService.service';
 import { TrustedDomainService } from 'vscode/vscode/vs/workbench/contrib/url/browser/trustedDomainService';
+import { LabelService } from './vscode/src/vs/workbench/services/label/common/labelService.js';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 import { getEnvironmentOverride } from 'vscode/workbench';
 
 let BrowserPathServiceOverride = class BrowserPathServiceOverride extends AbstractPathService {
@@ -50,7 +52,8 @@ function getServiceOverride() {
         [( IUserActivityService.toString())]: new SyncDescriptor(UserActivityService, [], true),
         [( IWorkingCopyFileService.toString())]: new SyncDescriptor(WorkingCopyFileService, [], false),
         [( IPathService.toString())]: new SyncDescriptor(BrowserPathServiceOverride, [], true),
-        [( ITrustedDomainService.toString())]: new SyncDescriptor(TrustedDomainService, [], true)
+        [( ITrustedDomainService.toString())]: new SyncDescriptor(TrustedDomainService, [], true),
+        [( ILabelService.toString())]: new SyncDescriptor(LabelService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-base-service-override",
-  "version": "7.0.3",
+  "version": "7.0.7",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@7.0.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@7.0.7"
   }
 }

package/vscode/src/vs/workbench/services/label/common/labelService.js

@@ -0,0 +1,418 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { dispose, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { sep, posix, win32 } from 'vscode/vscode/vs/base/common/path';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { isWorkspace, toWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, isUntitledWorkspace, isTemporaryWorkspace, WORKSPACE_EXTENSION } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { basenameOrAuthority, basename, joinPath, dirname } from 'vscode/vscode/vs/base/common/resources';
+import { getPathLabel, tildify } from 'vscode/vscode/vs/base/common/labels';
+import { Verbosity } from 'vscode/vscode/vs/platform/label/common/label';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { match } from 'vscode/vscode/vs/base/common/glob';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
+import { isProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { OS, OperatingSystem } from 'vscode/vscode/vs/base/common/platform';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
+
+const _moduleId = "vs/workbench/services/label/common/labelService";
+const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'resourceLabelFormatters',
+    jsonSchema: {
+        description: ( localizeWithPath(_moduleId, 0, 'Contributes resource label formatting rules.')),
+        type: 'array',
+        items: {
+            type: 'object',
+            required: ['scheme', 'formatting'],
+            properties: {
+                scheme: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        _moduleId,
+                        1,
+                        'URI scheme on which to match the formatter on. For example "file". Simple glob patterns are supported.'
+                    )),
+                },
+                authority: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        _moduleId,
+                        2,
+                        'URI authority on which to match the formatter on. Simple glob patterns are supported.'
+                    )),
+                },
+                formatting: {
+                    description: ( localizeWithPath(_moduleId, 3, "Rules for formatting uri resource labels.")),
+                    type: 'object',
+                    properties: {
+                        label: {
+                            type: 'string',
+                            description: ( localizeWithPath(
+                                _moduleId,
+                                4,
+                                "Label rules to display. For example: myLabel:/${path}. ${path}, ${scheme}, ${authority} and ${authoritySuffix} are supported as variables."
+                            ))
+                        },
+                        separator: {
+                            type: 'string',
+                            description: ( localizeWithPath(
+                                _moduleId,
+                                5,
+                                "Separator to be used in the uri label display. '/' or '\' as an example."
+                            ))
+                        },
+                        stripPathStartingSeparator: {
+                            type: 'boolean',
+                            description: ( localizeWithPath(
+                                _moduleId,
+                                6,
+                                "Controls whether `${path}` substitutions should have starting separator characters stripped."
+                            ))
+                        },
+                        tildify: {
+                            type: 'boolean',
+                            description: ( localizeWithPath(
+                                _moduleId,
+                                7,
+                                "Controls if the start of the uri label should be tildified when possible."
+                            ))
+                        },
+                        workspaceSuffix: {
+                            type: 'string',
+                            description: ( localizeWithPath(_moduleId, 8, "Suffix appended to the workspace label."))
+                        }
+                    }
+                }
+            }
+        }
+    }
+});
+const sepRegexp = /\//g;
+const labelMatchingRegexp = /\$\{(scheme|authoritySuffix|authority|path|(query)\.(.+?))\}/g;
+function hasDriveLetterIgnorePlatform(path) {
+    return !!(path && path[2] === ':');
+}
+let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
+    constructor(labelService) {
+        this.formattersDisposables = ( (new Map()));
+        resourceLabelFormattersExtPoint.setHandler((extensions, delta) => {
+            for (const added of delta.added) {
+                for (const untrustedFormatter of added.value) {
+                    const formatter = { ...untrustedFormatter };
+                    if (typeof formatter.formatting.label !== 'string') {
+                        formatter.formatting.label = '${authority}${path}';
+                    }
+                    if (typeof formatter.formatting.separator !== `string`) {
+                        formatter.formatting.separator = sep;
+                    }
+                    if (!isProposedApiEnabled(added.description, 'contribLabelFormatterWorkspaceTooltip') && formatter.formatting.workspaceTooltip) {
+                        formatter.formatting.workspaceTooltip = undefined;
+                    }
+                    this.formattersDisposables.set(formatter, labelService.registerFormatter(formatter));
+                }
+            }
+            for (const removed of delta.removed) {
+                for (const formatter of removed.value) {
+                    dispose(this.formattersDisposables.get(formatter));
+                }
+            }
+        });
+    }
+};
+ResourceLabelFormattersHandler = ( (__decorate([
+    ( (__param(0, ILabelService)))
+], ResourceLabelFormattersHandler)));
+( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(ResourceLabelFormattersHandler, LifecyclePhase.Restored);
+const FORMATTER_CACHE_SIZE = 50;
+let LabelService = class LabelService extends Disposable {
+    constructor(environmentService, contextService, pathService, remoteAgentService, storageService, lifecycleService) {
+        super();
+        this.environmentService = environmentService;
+        this.contextService = contextService;
+        this.pathService = pathService;
+        this.remoteAgentService = remoteAgentService;
+        this._onDidChangeFormatters = this._register(( (new Emitter({ leakWarningThreshold: 400 }))));
+        this.onDidChangeFormatters = this._onDidChangeFormatters.event;
+        this.os = OS;
+        this.userHome = pathService.defaultUriScheme === Schemas.file ? this.pathService.userHome({ preferLocal: true }) : undefined;
+        const memento = this.storedFormattersMemento = ( (new Memento('cachedResourceLabelFormatters2', storageService)));
+        this.storedFormatters = memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
+        this.formatters = this.storedFormatters?.formatters?.slice() || [];
+        this.resolveRemoteEnvironment();
+    }
+    async resolveRemoteEnvironment() {
+        const env = await this.remoteAgentService.getEnvironment();
+        this.os = env?.os ?? OS;
+        this.userHome = await this.pathService.userHome();
+    }
+    findFormatting(resource) {
+        let bestResult;
+        for (const formatter of this.formatters) {
+            if (formatter.scheme === resource.scheme) {
+                if (!formatter.authority && (!bestResult || formatter.priority)) {
+                    bestResult = formatter;
+                    continue;
+                }
+                if (!formatter.authority) {
+                    continue;
+                }
+                if (match(formatter.authority.toLowerCase(), resource.authority.toLowerCase()) &&
+                    (!bestResult ||
+                        !bestResult.authority ||
+                        formatter.authority.length > bestResult.authority.length ||
+                        ((formatter.authority.length === bestResult.authority.length) && formatter.priority))) {
+                    bestResult = formatter;
+                }
+            }
+        }
+        return bestResult ? bestResult.formatting : undefined;
+    }
+    getUriLabel(resource, options = {}) {
+        let formatting = this.findFormatting(resource);
+        if (formatting && options.separator) {
+            formatting = { ...formatting, separator: options.separator };
+        }
+        const label = this.doGetUriLabel(resource, formatting, options);
+        if (!formatting && options.separator) {
+            return label.replace(sepRegexp, options.separator);
+        }
+        return label;
+    }
+    doGetUriLabel(resource, formatting, options = {}) {
+        if (!formatting) {
+            return getPathLabel(resource, {
+                os: this.os,
+                tildify: this.userHome ? { userHome: this.userHome } : undefined,
+                relative: options.relative ? {
+                    noPrefix: options.noPrefix,
+                    getWorkspace: () => this.contextService.getWorkspace(),
+                    getWorkspaceFolder: resource => this.contextService.getWorkspaceFolder(resource)
+                } : undefined
+            });
+        }
+        if (options.relative && this.contextService) {
+            let folder = this.contextService.getWorkspaceFolder(resource);
+            if (!folder) {
+                const workspace = this.contextService.getWorkspace();
+                const firstFolder = firstOrDefault(workspace.folders);
+                if (firstFolder && resource.scheme !== firstFolder.uri.scheme && resource.path.startsWith(posix.sep)) {
+                    folder = this.contextService.getWorkspaceFolder(firstFolder.uri.with({ path: resource.path }));
+                }
+            }
+            if (folder) {
+                const folderLabel = this.formatUri(folder.uri, formatting, options.noPrefix);
+                let relativeLabel = this.formatUri(resource, formatting, options.noPrefix);
+                let overlap = 0;
+                while (relativeLabel[overlap] && relativeLabel[overlap] === folderLabel[overlap]) {
+                    overlap++;
+                }
+                if (!relativeLabel[overlap] || relativeLabel[overlap] === formatting.separator) {
+                    relativeLabel = relativeLabel.substring(1 + overlap);
+                }
+                else if (overlap === folderLabel.length && folder.uri.path === posix.sep) {
+                    relativeLabel = relativeLabel.substring(overlap);
+                }
+                const hasMultipleRoots = this.contextService.getWorkspace().folders.length > 1;
+                if (hasMultipleRoots && !options.noPrefix) {
+                    const rootName = folder?.name ?? basenameOrAuthority(folder.uri);
+                    relativeLabel = relativeLabel ? `${rootName} • ${relativeLabel}` : rootName;
+                }
+                return relativeLabel;
+            }
+        }
+        return this.formatUri(resource, formatting, options.noPrefix);
+    }
+    getUriBasenameLabel(resource) {
+        const formatting = this.findFormatting(resource);
+        const label = this.doGetUriLabel(resource, formatting);
+        let pathLib;
+        if (formatting?.separator === win32.sep) {
+            pathLib = win32;
+        }
+        else if (formatting?.separator === posix.sep) {
+            pathLib = posix;
+        }
+        else {
+            pathLib = (this.os === OperatingSystem.Windows) ? win32 : posix;
+        }
+        return pathLib.basename(label);
+    }
+    getWorkspaceLabel(workspace, options) {
+        if (isWorkspace(workspace)) {
+            const identifier = toWorkspaceIdentifier(workspace);
+            if (isSingleFolderWorkspaceIdentifier(identifier) || isWorkspaceIdentifier(identifier)) {
+                return this.getWorkspaceLabel(identifier, options);
+            }
+            return '';
+        }
+        if (URI.isUri(workspace)) {
+            return this.doGetSingleFolderWorkspaceLabel(workspace, options);
+        }
+        if (isSingleFolderWorkspaceIdentifier(workspace)) {
+            return this.doGetSingleFolderWorkspaceLabel(workspace.uri, options);
+        }
+        if (isWorkspaceIdentifier(workspace)) {
+            return this.doGetWorkspaceLabel(workspace.configPath, options);
+        }
+        return '';
+    }
+    doGetWorkspaceLabel(workspaceUri, options) {
+        if (isUntitledWorkspace(workspaceUri, this.environmentService)) {
+            return ( localizeWithPath(_moduleId, 9, "Untitled (Workspace)"));
+        }
+        if (isTemporaryWorkspace(workspaceUri)) {
+            return ( localizeWithPath(_moduleId, 10, "Workspace"));
+        }
+        let filename = basename(workspaceUri);
+        if (filename.endsWith(WORKSPACE_EXTENSION)) {
+            filename = filename.substr(0, filename.length - WORKSPACE_EXTENSION.length - 1);
+        }
+        let label;
+        switch (options?.verbose) {
+            case Verbosity.SHORT:
+                label = filename;
+                break;
+            case Verbosity.LONG:
+                label = ( localizeWithPath(
+                    _moduleId,
+                    11,
+                    "{0} (Workspace)",
+                    this.getUriLabel(joinPath(dirname(workspaceUri), filename))
+                ));
+                break;
+            case Verbosity.MEDIUM:
+            default:
+                label = ( localizeWithPath(_moduleId, 12, "{0} (Workspace)", filename));
+                break;
+        }
+        if (options?.verbose === Verbosity.SHORT) {
+            return label;
+        }
+        return this.appendWorkspaceSuffix(label, workspaceUri);
+    }
+    doGetSingleFolderWorkspaceLabel(folderUri, options) {
+        let label;
+        switch (options?.verbose) {
+            case Verbosity.LONG:
+                label = this.getUriLabel(folderUri);
+                break;
+            case Verbosity.SHORT:
+            case Verbosity.MEDIUM:
+            default:
+                label = basename(folderUri) || posix.sep;
+                break;
+        }
+        if (options?.verbose === Verbosity.SHORT) {
+            return label;
+        }
+        return this.appendWorkspaceSuffix(label, folderUri);
+    }
+    getSeparator(scheme, authority) {
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
+        return formatter?.separator || posix.sep;
+    }
+    getHostLabel(scheme, authority) {
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
+        return formatter?.workspaceSuffix || authority || '';
+    }
+    getHostTooltip(scheme, authority) {
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
+        return formatter?.workspaceTooltip;
+    }
+    registerCachedFormatter(formatter) {
+        const list = this.storedFormatters.formatters ??= [];
+        let replace = list.findIndex(f => f.scheme === formatter.scheme && f.authority === formatter.authority);
+        if (replace === -1 && list.length >= FORMATTER_CACHE_SIZE) {
+            replace = FORMATTER_CACHE_SIZE - 1;
+        }
+        if (replace === -1) {
+            list.unshift(formatter);
+        }
+        else {
+            for (let i = replace; i > 0; i--) {
+                list[i] = list[i - 1];
+            }
+            list[0] = formatter;
+        }
+        this.storedFormattersMemento.saveMemento();
+        return this.registerFormatter(formatter);
+    }
+    registerFormatter(formatter) {
+        this.formatters.push(formatter);
+        this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+        return {
+            dispose: () => {
+                this.formatters = this.formatters.filter(f => f !== formatter);
+                this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+            }
+        };
+    }
+    formatUri(resource, formatting, forceNoTildify) {
+        let label = formatting.label.replace(labelMatchingRegexp, (match, token, qsToken, qsValue) => {
+            switch (token) {
+                case 'scheme': return resource.scheme;
+                case 'authority': return resource.authority;
+                case 'authoritySuffix': {
+                    const i = resource.authority.indexOf('+');
+                    return i === -1 ? resource.authority : resource.authority.slice(i + 1);
+                }
+                case 'path':
+                    return formatting.stripPathStartingSeparator
+                        ? resource.path.slice(resource.path[0] === formatting.separator ? 1 : 0)
+                        : resource.path;
+                default: {
+                    if (qsToken === 'query') {
+                        const { query } = resource;
+                        if (query && query[0] === '{' && query[query.length - 1] === '}') {
+                            try {
+                                return JSON.parse(query)[qsValue] || '';
+                            }
+                            catch { }
+                        }
+                    }
+                    return '';
+                }
+            }
+        });
+        if (formatting.normalizeDriveLetter && hasDriveLetterIgnorePlatform(label)) {
+            label = label.charAt(1).toUpperCase() + label.substr(2);
+        }
+        if (formatting.tildify && !forceNoTildify) {
+            if (this.userHome) {
+                label = tildify(label, this.userHome.fsPath, this.os);
+            }
+        }
+        if (formatting.authorityPrefix && resource.authority) {
+            label = formatting.authorityPrefix + label;
+        }
+        return label.replace(sepRegexp, formatting.separator);
+    }
+    appendWorkspaceSuffix(label, uri) {
+        const formatting = this.findFormatting(uri);
+        const suffix = formatting && (typeof formatting.workspaceSuffix === 'string') ? formatting.workspaceSuffix : undefined;
+        return suffix ? `${label} [${suffix}]` : label;
+    }
+};
+LabelService = ( (__decorate([
+    ( (__param(0, IWorkbenchEnvironmentService))),
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IPathService))),
+    ( (__param(3, IRemoteAgentService))),
+    ( (__param(4, IStorageService))),
+    ( (__param(5, ILifecycleService)))
+], LabelService)));
+
+export { LabelService };