@codingame/monaco-vscode-base-service-override 37.6.1 → 38.0.1

package/index.js

@@ -17,13 +17,13 @@ import { ICanonicalUriService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { IUserActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userActivity/common/userActivityService.service';
 import { IDownloadService } from '@codingame/monaco-vscode-api/vscode/vs/platform/download/common/download.service';
 import { DownloadService } from './vscode/src/vs/platform/download/common/downloadService.js';
-import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/platform/path/common/pathService.service';
 import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { guessLocalUserHome } from './vscode/src/vs/workbench/services/path/browser/pathService.js';
-import { AbstractPathService } from './vscode/src/vs/workbench/services/path/common/pathService.js';
+import { AbstractPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
 import { UserActivityService } from './vscode/src/vs/workbench/services/userActivity/common/userActivityService.js';
 import { WorkingCopyFileService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyFileService.js';
 import { ITrustedDomainService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/common/trustedDomainService.service';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-base-service-override",
-  "version": "37.6.1",
+  "version": "38.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - base service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.6.1"
+    "@codingame/monaco-vscode-api": "38.0.1"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/parts/request/common/requestImpl.d.ts

@@ -1,3 +1,3 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { IRequestContext, IRequestOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/request/common/request";
-export declare function request(options: IRequestOptions, token: CancellationToken, isOnline?: () => boolean): Promise<IRequestContext>;
+export declare function request(options: IRequestOptions, token: CancellationToken, isOnline?: () => boolean, fetcher?: typeof fetch): Promise<IRequestContext>;

package/vscode/src/vs/base/parts/request/common/requestImpl.js

@@ -1,15 +1,27 @@
 
 import { bufferToStream, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { canceled } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { mark, clearMarks } from '@codingame/monaco-vscode-api/vscode/vs/base/common/performance';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { OfflineError } from '@codingame/monaco-vscode-api/vscode/vs/base/parts/request/common/request';
 
-async function request(options, token, isOnline) {
+async function request(options, token, isOnline, fetcher = fetch) {
     if (token.isCancellationRequested) {
         throw canceled();
     }
     const cancellation = ( new AbortController());
     const disposable = token.onCancellationRequested(() => cancellation.abort());
     const signal = options.timeout ? AbortSignal.any([cancellation.signal, AbortSignal.timeout(options.timeout)]) : cancellation.signal;
+    const watch = options.diagnosticId ? StopWatch.create(false) : undefined;
+    const marks = [];
+    let phase = "headers";
+    const trace = event => {
+        if (options.diagnosticId) {
+            const name = `code/request/${options.diagnosticId}/${event}`;
+            marks.push(name);
+            mark(name);
+        }
+    };
     try {
         const fetchInit = {
             method: options.type || "GET",
@@ -23,15 +35,32 @@ async function request(options, token, isOnline) {
         if (options.followRedirects === 0) {
             fetchInit.redirect = "manual";
         }
-        const res = await fetch(options.url || "", fetchInit);
+        trace("start");
+        const res = await fetcher(options.url || "", fetchInit);
+        const responseHeadersMs = watch?.elapsed();
+        trace("headersReceived");
+        phase = "body";
+        const body = ( new Uint8Array(await res.arrayBuffer()));
+        const responseBodyMs = watch && responseHeadersMs !== undefined ? watch.elapsed() - responseHeadersMs : undefined;
+        trace("bodyReceived");
         return {
             res: {
                 statusCode: res.status,
                 headers: getResponseHeaders(res)
             },
-            stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(await res.arrayBuffer()))))
+            stream: bufferToStream(VSBuffer.wrap(body)),
+            ...(responseHeadersMs !== undefined && responseBodyMs !== undefined ? {
+                timings: {
+                    responseHeadersMs,
+                    responseBodyMs,
+                    decodedBodyBytes: body.byteLength
+                }
+            } : {})
         };
     } catch (err) {
+        trace(
+            `${phase}/${token.isCancellationRequested || err?.name === "AbortError" ? "cancelled" : "failed"}`
+        );
         if (isOnline && !isOnline()) {
             throw ( new OfflineError());
         }
@@ -44,6 +73,9 @@ async function request(options, token, isOnline) {
         throw err;
     } finally {
         disposable.dispose();
+        for (const name of marks) {
+            clearMarks(name);
+        }
     }
 }
 function getRequestHeaders(options) {

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -9,10 +9,13 @@ class RequestChannelClient {
         this.onDidCompleteRequest = Event.None;
     }
     async request(options, token) {
-        const [res, buffer] = await this.channel.call("request", [options], token);
+        const [res, buffer, timings] = await this.channel.call("request", [options], token);
         return {
             res,
-            stream: bufferToStream(buffer)
+            stream: bufferToStream(buffer),
+            ...(timings ? {
+                timings
+            } : {})
         };
     }
     async resolveProxy(url) {

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -137,7 +137,7 @@ let JSONEditingService = class JSONEditingService {
         case JSONEditingErrorCode.ERROR_INVALID_FILE:
             {
                 return localize(
-                    21769,
+                    24344,
                     "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
                 );
             }

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -180,15 +180,19 @@ class DecorationStyles {
         const iconClassName = rule.iconBadgeClassName;
         let tooltip = distinct(data.filter(d => !isFalsyOrWhitespace(d.tooltip)).map(d => d.tooltip)).join(" • ");
         const strikethrough = ( data.some(d => d.strikethrough));
+        const isTextBadge = !onlyChildren && !( data.some(decoration => ThemeIcon.isThemeIcon(decoration.letter))) && ( data.some(
+            decoration => typeof decoration.letter === "string" && decoration.letter.length > 0
+        ));
         if (onlyChildren) {
             badgeClassName = rule.bubbleBadgeClassName;
-            tooltip = ( localize(21819, "Contains emphasized items"));
+            tooltip = ( localize(24394, "Contains emphasized items"));
         }
         return {
             labelClassName,
             badgeClassName,
             iconClassName,
             strikethrough,
+            isTextBadge,
             tooltip,
             dispose: () => {
                 if (rule?.release()) {

package/vscode/src/vs/workbench/services/label/common/labelService.d.ts

@@ -6,14 +6,16 @@ import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs
 import { ResourceLabelFormatter, ResourceLabelFormatting, IFormatterChangeEvent, Verbosity, ResourceLabelTemplateFormatter } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
-import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService";
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 export declare class LabelService extends Disposable implements ILabelService {
     private readonly environmentService;
     private readonly contextService;
     private readonly pathService;
     private readonly remoteAgentService;
+    private readonly uriIdentityService;
     readonly _serviceBrand: undefined;
     private formatters;
     private homeFormatters;
@@ -23,7 +25,7 @@ export declare class LabelService extends Disposable implements ILabelService {
     private readonly storedFormatters;
     private os;
     private userHome;
-    constructor(environmentService: IWorkbenchEnvironmentService, contextService: IWorkspaceContextService, pathService: IPathService, remoteAgentService: IRemoteAgentService, storageService: IStorageService, lifecycleService: ILifecycleService);
+    constructor(environmentService: IWorkbenchEnvironmentService, contextService: IWorkspaceContextService, pathService: IPathService, remoteAgentService: IRemoteAgentService, storageService: IStorageService, lifecycleService: ILifecycleService, uriIdentityService: IUriIdentityService);
     private resolveRemoteEnvironment;
     getUriHome(resource: URI): URI | undefined;
     private findHomeFormatter;

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

@@ -10,7 +10,7 @@ import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/regist
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { isWorkspace, toWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, isUntitledWorkspace, isTemporaryWorkspace, WORKSPACE_EXTENSION } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { isEqualOrParent, relativePath, basenameOrAuthority, basename, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { basenameOrAuthority, basename, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { getPathLabel, tildify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
 import { Verbosity } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
@@ -19,7 +19,7 @@ import { match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
 import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
-import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
 import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
@@ -27,12 +27,14 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { Memento } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
-import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ResourceLabelTemplate } from './resourceLabelTemplate.js';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/platform/path/common/pathService.service';
 
 const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "resourceLabelFormatters",
     jsonSchema: {
-        description: ( localize(22134, "Contributes resource label formatting rules.")),
+        description: ( localize(24714, "Contributes resource label formatting rules.")),
         type: "array",
         items: {
             type: "object",
@@ -41,52 +43,52 @@ const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoin
                 scheme: {
                     type: "string",
                     description: ( localize(
-                        22135,
+                        24715,
                         "URI scheme on which to match the formatter on. For example \"file\". Simple glob patterns are supported."
                     ))
                 },
                 authority: {
                     type: "string",
                     description: ( localize(
-                        22136,
+                        24716,
                         "URI authority on which to match the formatter on. Simple glob patterns are supported."
                     ))
                 },
                 formatting: {
-                    description: ( localize(22137, "Rules for formatting uri resource labels.")),
+                    description: ( localize(24717, "Rules for formatting uri resource labels.")),
                     type: "object",
                     properties: {
                         label: {
                             type: "string",
                             description: ( localize(
-                                22138,
+                                24718,
                                 "Label rules to display. For example: myLabel:/${path}. ${path}, ${scheme}, ${authority} and ${authoritySuffix} are supported as variables."
                             ))
                         },
                         separator: {
                             type: "string",
                             description: ( localize(
-                                22139,
+                                24719,
                                 "Separator to be used in the uri label display. '/' or '' as an example."
                             ))
                         },
                         stripPathStartingSeparator: {
                             type: "boolean",
                             description: ( localize(
-                                22140,
+                                24720,
                                 "Controls whether `${path}` substitutions should have starting separator characters stripped."
                             ))
                         },
                         tildify: {
                             type: "boolean",
                             description: ( localize(
-                                22141,
+                                24721,
                                 "Controls if the start of the uri label should be tildified when possible."
                             ))
                         },
                         workspaceSuffix: {
                             type: "string",
-                            description: ( localize(22142, "Suffix appended to the workspace label."))
+                            description: ( localize(24722, "Suffix appended to the workspace label."))
                         }
                     }
                 }
@@ -132,7 +134,6 @@ let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
 ResourceLabelFormattersHandler = ( __decorate([( __param(0, ILabelService))], ResourceLabelFormattersHandler));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ResourceLabelFormattersHandler, LifecyclePhase.Restored);
 const FORMATTER_CACHE_SIZE = 50;
-const homeTemplateParameterRegex = /^\$\{(?<name>[a-zA-Z_][\w]*)\}$/;
 function isTemplateFormatter(formatter) {
     return URI.isUri(formatter.home);
 }
@@ -143,13 +144,15 @@ let LabelService = class LabelService extends Disposable {
         pathService,
         remoteAgentService,
         storageService,
-        lifecycleService
+        lifecycleService,
+        uriIdentityService
     ) {
         super();
         this.environmentService = environmentService;
         this.contextService = contextService;
         this.pathService = pathService;
         this.remoteAgentService = remoteAgentService;
+        this.uriIdentityService = uriIdentityService;
         this.homeFormatters = [];
         this._onDidChangeFormatters = this._register(( new Emitter({
             leakWarningThreshold: 400,
@@ -182,29 +185,23 @@ let LabelService = class LabelService extends Disposable {
             if (formatter.home.scheme !== resource.scheme || (formatter.home.authority && formatter.home.authority.toLowerCase() !== resource.authority.toLowerCase())) {
                 continue;
             }
-            const templateMatch = registration.templateMatcher.exec(resource.path);
+            const templateMatch = registration.template.match(resource, this.uriIdentityService.extUri);
             if (!templateMatch) {
                 continue;
             }
-            const parameters = ( new Map(Object.entries(templateMatch.groups ?? {})));
-            const home = resource.with({
-                path: templateMatch[0],
-                query: null,
-                fragment: null
-            });
             const formatting = formatter.formatting({
                 resource,
-                home,
-                parameters
+                home: templateMatch.home,
+                parameters: templateMatch.parameters
             });
             if (!formatting) {
                 continue;
             }
             const result = {
-                home,
+                home: templateMatch.home,
                 formatting,
                 literalLabel: true,
-                homeLength: home.path.length,
+                homeLength: templateMatch.home.path.length,
                 authorityLength: formatter.home.authority.length
             };
             if (!bestResult || result.homeLength > bestResult.homeLength || (result.homeLength === bestResult.homeLength && result.authorityLength > bestResult.authorityLength) || (result.homeLength === bestResult.homeLength && result.authorityLength === bestResult.authorityLength && !bestResultIsTemplate)) {
@@ -219,7 +216,7 @@ let LabelService = class LabelService extends Disposable {
         for (const formatter of this.formatters) {
             if (!formatter.home || formatter.scheme !== resource.scheme || (formatter.authority && !match(formatter.authority, resource.authority, {
                 ignoreCase: true
-            })) || !isEqualOrParent(resource, resource.with({
+            })) || !this.uriIdentityService.extUri.isEqualOrParent(resource, resource.with({
                 path: formatter.home
             }))) {
                 continue;
@@ -266,7 +263,10 @@ let LabelService = class LabelService extends Disposable {
         const homeFormatter = options.noPrefix ? undefined : this.findHomeFormatter(resource);
         if (homeFormatter) {
             const separator = options.separator ?? homeFormatter.formatting.separator;
-            const path = relativePath(homeFormatter.home, resource);
+            const homeWithResourceCasing = homeFormatter.home.with({
+                path: resource.path.slice(0, homeFormatter.home.path.length)
+            });
+            const path = this.uriIdentityService.extUri.relativePath(homeWithResourceCasing, resource);
             const label = homeFormatter.literalLabel ? homeFormatter.formatting.label : this.formatUri(homeFormatter.home, homeFormatter.formatting);
             return path ? `${label}${separator}${this.adjustPathSeparators(path, separator)}` : label;
         }
@@ -367,10 +367,10 @@ let LabelService = class LabelService extends Disposable {
     }
     doGetWorkspaceLabel(workspaceUri, options) {
         if (isUntitledWorkspace(workspaceUri, this.environmentService)) {
-            return localize(22143, "Untitled (Workspace)");
+            return localize(24723, "Untitled (Workspace)");
         }
         if (isTemporaryWorkspace(workspaceUri)) {
-            return localize(22144, "Workspace");
+            return localize(24724, "Workspace");
         }
         let filename = basename(workspaceUri);
         if (filename.endsWith(WORKSPACE_EXTENSION)) {
@@ -383,14 +383,14 @@ let LabelService = class LabelService extends Disposable {
             break;
         case Verbosity.LONG:
             label = ( localize(
-                22145,
+                24725,
                 "{0} (Workspace)",
                 this.getUriLabel(joinPath(dirname(workspaceUri), filename))
             ));
             break;
         case Verbosity.MEDIUM:
         default:
-            label = ( localize(22146, "{0} (Workspace)", filename));
+            label = ( localize(24726, "{0} (Workspace)", filename));
             break;
         }
         if (options?.verbose === Verbosity.SHORT) {
@@ -484,32 +484,9 @@ let LabelService = class LabelService extends Disposable {
         };
     }
     createTemplateFormatterRegistration(formatter) {
-        const {
-            home
-        } = formatter;
-        const homePath = home.path.length > 1 ? home.path.replace(/\/+$/, "") : home.path;
-        const parameterNames = ( new Set());
-        const matcherPattern = homePath.split("/").map(segment => {
-            const parameterMatch = homeTemplateParameterRegex.exec(segment);
-            if (parameterMatch?.groups?.name) {
-                const parameterName = parameterMatch.groups.name;
-                if (( parameterNames.has(parameterName))) {
-                    throw ( new Error(`Duplicate resource label home template parameter: ${parameterName}`));
-                }
-                parameterNames.add(parameterName);
-                return `(?<${parameterName}>(?!\\.{1,2}(?:/|$))[^/]+)`;
-            }
-            if (segment.includes("${")) {
-                throw ( new Error(
-                    `Resource label home template parameters must occupy an entire path segment: ${segment}`
-                ));
-            }
-            return escapeRegExpCharacters(segment);
-        }).join("/");
-        const isRootHome = homePath === "" || homePath === "/";
         return {
             formatter,
-            templateMatcher: ( new RegExp(`^${matcherPattern}${isRootHome ? "" : "(?=/|$)"}`))
+            template: ( new ResourceLabelTemplate(formatter.home))
         };
     }
     formatUri(resource, formatting, forceNoTildify) {
@@ -581,6 +558,6 @@ let LabelService = class LabelService extends Disposable {
         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));
+LabelService = ( __decorate([( __param(0, IWorkbenchEnvironmentService)), ( __param(1, IWorkspaceContextService)), ( __param(2, IPathService)), ( __param(3, IRemoteAgentService)), ( __param(4, IStorageService)), ( __param(5, ILifecycleService)), ( __param(6, IUriIdentityService))], LabelService));
 
 export { LabelService };

package/vscode/src/vs/workbench/services/label/common/resourceLabelTemplate.d.ts

@@ -0,0 +1,13 @@
+import { IExtUri } from "@codingame/monaco-vscode-api/vscode/vs/base/common/resources";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export interface IResourceLabelTemplateMatch {
+    readonly home: URI;
+    readonly parameters: ReadonlyMap<string, string>;
+}
+export declare class ResourceLabelTemplate {
+    private readonly home;
+    private readonly segments;
+    private readonly isRoot;
+    constructor(home: URI);
+    match(resource: URI, extUri: IExtUri): IResourceLabelTemplateMatch | undefined;
+}

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

@@ -0,0 +1,89 @@
+
+import { isEqualAuthority } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+
+const templateParameterRegex = /^\$\{(?<name>[a-zA-Z_][\w]*)\}$/;
+class ResourceLabelTemplate {
+    constructor(home) {
+        this.home = home;
+        const homePath = home.path.length > 1 ? home.path.replace(/\/+$/, "") : home.path;
+        this.isRoot = homePath === "" || homePath === "/";
+        const parameterNames = ( new Set());
+        this.segments = this.isRoot ? [] : homePath.split("/").map(segment => {
+            const parameterMatch = templateParameterRegex.exec(segment);
+            if (parameterMatch?.groups?.name) {
+                const parameter = parameterMatch.groups.name;
+                if (( parameterNames.has(parameter))) {
+                    throw ( new Error(`Duplicate resource label home template parameter: ${parameter}`));
+                }
+                parameterNames.add(parameter);
+                return {
+                    kind: "parameter",
+                    value: parameter
+                };
+            }
+            if (segment.includes("${")) {
+                throw ( new Error(
+                    `Resource label home template parameters must occupy an entire path segment: ${segment}`
+                ));
+            }
+            return {
+                kind: "literal",
+                value: segment
+            };
+        });
+    }
+    match(resource, extUri) {
+        if (this.home.scheme !== resource.scheme || (this.home.authority && !isEqualAuthority(this.home.authority, resource.authority))) {
+            return undefined;
+        }
+        if (this.isRoot) {
+            return {
+                home: resource.with({
+                    path: this.home.path,
+                    query: null,
+                    fragment: null
+                }),
+                parameters: ( new Map())
+            };
+        }
+        const resourceSegments = resource.path.split("/");
+        if (resourceSegments.length < this.segments.length) {
+            return undefined;
+        }
+        const parameters = ( new Map());
+        for (let index = 0; index < this.segments.length; index++) {
+            const templateSegment = this.segments[index];
+            const resourceSegment = resourceSegments[index];
+            if (templateSegment.kind === "parameter") {
+                if (resourceSegment === "." || resourceSegment === "..") {
+                    return undefined;
+                }
+                parameters.set(templateSegment.value, resourceSegment);
+                continue;
+            }
+            const resourceSegmentUri = resource.with({
+                path: `/${resourceSegment}`,
+                query: null,
+                fragment: null
+            });
+            const templateSegmentUri = resource.with({
+                path: `/${templateSegment.value}`,
+                query: null,
+                fragment: null
+            });
+            if (!extUri.isEqual(resourceSegmentUri, templateSegmentUri)) {
+                return undefined;
+            }
+        }
+        return {
+            home: resource.with({
+                path: resourceSegments.slice(0, this.segments.length).join("/"),
+                query: null,
+                fragment: null
+            }),
+            parameters
+        };
+    }
+}
+
+export { ResourceLabelTemplate };

package/vscode/src/vs/workbench/services/path/browser/pathService.d.ts

@@ -1,5 +1,5 @@
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
-import { AbstractPathService } from "../common/pathService.js";
+import { AbstractPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";

package/vscode/src/vs/workbench/services/path/browser/pathService.js

@@ -1,7 +1,7 @@
 
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { AbstractPathService } from '../common/pathService.js';
+import { AbstractPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 

package/vscode/src/vs/workbench/services/request/browser/requestService.js

@@ -15,7 +15,7 @@ import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/
 let BrowserRequestService = class BrowserRequestService extends AbstractRequestService {
     constructor(remoteAgentService, configurationService, loggerService) {
         const logger = loggerService.createLogger(`network`, {
-            name: ( localize(22278, "Network")),
+            name: ( localize(24874, "Network")),
             group: windowLogGroup
         });
         const logService = ( new LogService(logger));

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant.js

@@ -9,6 +9,7 @@ import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs
 import { LinkedList } from '@codingame/monaco-vscode-api/vscode/vs/base/common/linkedList';
 import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { NotificationPriority } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { NotificationTelemetryId } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notificationTelemetry';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 
 let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySaveParticipant extends Disposable {
@@ -29,13 +30,14 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
         const cts = ( new CancellationTokenSource(token));
         workingCopy.model?.pushStackElement();
         progress.report({
-            message: ( localize(22681, "Running Code Actions and Formatters..."))
+            message: ( localize(25277, "Running Code Actions and Formatters..."))
         });
         let bubbleCancel = false;
         await this.progressService.withProgress({
+            telemetry: NotificationTelemetryId.WorkingCopySaveParticipants,
             priority: NotificationPriority.URGENT,
             location: ProgressLocation.Notification,
-            cancellable: ( localize(22682, "Skip")),
+            cancellable: ( localize(25278, "Skip")),
             delay: workingCopy.isDirty() ? 5000 : 3000
         }, async progress => {
             const participants = Array.from(this.saveParticipants).sort((a, b) => {

package/vscode/src/vs/workbench/services/path/common/pathService.d.ts

@@ -1,32 +0,0 @@
-import { IPath } from "@codingame/monaco-vscode-api/vscode/vs/base/common/path";
-import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
-import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
-import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
-import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
-export declare abstract class AbstractPathService implements IPathService {
-    private localUserHome;
-    private readonly remoteAgentService;
-    private readonly environmentService;
-    private contextService;
-    readonly _serviceBrand: undefined;
-    private resolveOS;
-    private resolveUserHome;
-    private maybeUnresolvedUserHome;
-    constructor(localUserHome: URI, remoteAgentService: IRemoteAgentService, environmentService: IWorkbenchEnvironmentService, contextService: IWorkspaceContextService);
-    hasValidBasename(resource: URI, basename?: string): Promise<boolean>;
-    hasValidBasename(resource: URI, os: OperatingSystem, basename?: string): boolean;
-    private doHasValidBasename;
-    get defaultUriScheme(): string;
-    static findDefaultUriScheme(environmentService: IWorkbenchEnvironmentService, contextService: IWorkspaceContextService): string;
-    userHome(options?: {
-        preferLocal: boolean;
-    }): Promise<URI>;
-    userHome(options: {
-        preferLocal: true;
-    }): URI;
-    get resolvedUserHome(): URI | undefined;
-    get path(): Promise<IPath>;
-    fileURI(_path: string): Promise<URI>;
-}

package/vscode/src/vs/workbench/services/path/common/pathService.js

@@ -1,102 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { isValidBasename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/extpath';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { getVirtualWorkspaceScheme } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/virtualWorkspace';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
-
-var AbstractPathService_1;
-let AbstractPathService = AbstractPathService_1 = class AbstractPathService {
-    constructor(localUserHome, remoteAgentService, environmentService, contextService) {
-        this.localUserHome = localUserHome;
-        this.remoteAgentService = remoteAgentService;
-        this.environmentService = environmentService;
-        this.contextService = contextService;
-        this.resolveOS = (async () => {
-            const env = await this.remoteAgentService.getEnvironment();
-            return env?.os || OS;
-        })();
-        this.resolveUserHome = (async () => {
-            const env = await this.remoteAgentService.getEnvironment();
-            const userHome = this.maybeUnresolvedUserHome = env?.userHome ?? localUserHome;
-            return userHome;
-        })();
-    }
-    hasValidBasename(resource, arg2, basename) {
-        if (typeof arg2 === "string" || typeof arg2 === "undefined") {
-            return this.resolveOS.then(os => this.doHasValidBasename(resource, os, arg2));
-        }
-        return this.doHasValidBasename(resource, arg2, basename);
-    }
-    doHasValidBasename(resource, os, name) {
-        if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeRemote) {
-            return isValidBasename(name ?? basename(resource), os === OperatingSystem.Windows);
-        }
-        return true;
-    }
-    get defaultUriScheme() {
-        return AbstractPathService_1.findDefaultUriScheme(this.environmentService, this.contextService);
-    }
-    static findDefaultUriScheme(environmentService, contextService) {
-        if (environmentService.remoteAuthority) {
-            return Schemas.vscodeRemote;
-        }
-        const virtualWorkspace = getVirtualWorkspaceScheme(contextService.getWorkspace());
-        if (virtualWorkspace) {
-            return virtualWorkspace;
-        }
-        const firstFolder = contextService.getWorkspace().folders[0];
-        if (firstFolder) {
-            return firstFolder.uri.scheme;
-        }
-        const configuration = contextService.getWorkspace().configuration;
-        if (configuration) {
-            return configuration.scheme;
-        }
-        return Schemas.file;
-    }
-    userHome(options) {
-        return options?.preferLocal ? this.localUserHome : this.resolveUserHome;
-    }
-    get resolvedUserHome() {
-        return this.maybeUnresolvedUserHome;
-    }
-    get path() {
-        return this.resolveOS.then(os => {
-            return os === OperatingSystem.Windows ? win32 : posix;
-        });
-    }
-    async fileURI(_path) {
-        let authority = "";
-        const os = await this.resolveOS;
-        if (os === OperatingSystem.Windows) {
-            _path = _path.replace(/\\/g, "/");
-        }
-        if (_path[0] === "/" && _path[1] === "/") {
-            const idx = _path.indexOf("/", 2);
-            if (idx === -1) {
-                authority = _path.substring(2);
-                _path = "/";
-            } else {
-                authority = _path.substring(2, idx);
-                _path = _path.substring(idx) || "/";
-            }
-        }
-        return ( URI.from({
-            scheme: Schemas.file,
-            authority,
-            path: _path,
-            query: "",
-            fragment: ""
-        }));
-    }
-};
-AbstractPathService = AbstractPathService_1 = ( __decorate([( __param(1, IRemoteAgentService)), ( __param(2, IWorkbenchEnvironmentService)), ( __param(3, IWorkspaceContextService))], AbstractPathService));
-
-export { AbstractPathService };