@codingame/monaco-vscode-workspace-trust-service-override 38.0.7 → 39.0.0

package/package.json

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

package/vscode/src/vs/workbench/contrib/workspace/browser/workspace.contribution.js

@@ -64,13 +64,13 @@ function getSessionsWindowTrustNote(environmentService, productService, isWorksp
     }
     if (isWorkspace) {
         return localize(
-            23961,
+            26921,
             "Trusting this workspace will also mark it as trusted in {0}.",
             productService.nameLong
         );
     }
     return localize(
-        23962,
+        26922,
         "Trusting this folder will also mark it as trusted in {0}.",
         productService.nameLong
     );
@@ -127,29 +127,29 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
                 await this.workspaceTrustManagementService.workspaceResolved;
                 const markdownDetails = [
                     this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY ? ( localize(
-                        23963,
+                        26923,
                         "You are trying to open untrusted files in a workspace which is trusted."
                     )) : ( localize(
-                        23964,
+                        26924,
                         "You are trying to open untrusted files in a window which is trusted."
                     )),
                     ( localize(
-                    23965,
+                    26925,
                     "If you don't want to open untrusted files, we recommend to open them in Restricted Mode in a new window as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
                 ))
                 ];
                 await this.dialogService.prompt({
                     type: Severity.Info,
-                    message: this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY ? ( localize(23966, "Do you want to allow untrusted files in this workspace?")) : ( localize(23967, "Do you want to allow untrusted files in this window?")),
+                    message: this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY ? ( localize(26926, "Do you want to allow untrusted files in this workspace?")) : ( localize(26927, "Do you want to allow untrusted files in this window?")),
                     buttons: [{
-                        label: ( localize(23968, "&&Open")),
+                        label: ( localize(26928, "&&Open")),
                         run: (
                             {
                                 checkboxChecked
                             }
                         ) => this.workspaceTrustRequestService.completeOpenFilesTrustRequest(WorkspaceTrustUriResponse.Open, !!checkboxChecked)
                     }, {
-                        label: ( localize(23969, "Open in &&Restricted Mode")),
+                        label: ( localize(26929, "Open in &&Restricted Mode")),
                         run: (
                             {
                                 checkboxChecked
@@ -160,7 +160,7 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
                         run: () => this.workspaceTrustRequestService.completeOpenFilesTrustRequest(WorkspaceTrustUriResponse.Cancel)
                     },
                     checkbox: {
-                        label: ( localize(23970, "Remember my decision for all workspaces")),
+                        label: ( localize(26930, "Remember my decision for all workspaces")),
                         checked: false
                     },
                     custom: {
@@ -178,10 +178,10 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
             this.workspaceTrustRequestService.onDidInitiateResourcesTrustRequest(async options => {
                 await this.workspaceTrustManagementService.workspaceResolved;
                 const markdownDetails = [options?.message ?? ( localize(
-                    23971,
+                    26931,
                     "You are trying to open an untrusted folder. Do you trust the authors of this content?"
                 )), ( localize(
-                    23972,
+                    26932,
                     "If you don't trust the authors of these files, we recommend not continuing as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
                 )), `\`${this.labelService.getUriLabel(options.uri)}\``];
                 const sessionsTrustNote = getSessionsWindowTrustNote(this.environmentService, this.productService, false);
@@ -190,9 +190,9 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
                 }
                 await this.dialogService.prompt({
                     type: Severity.Info,
-                    message: ( localize(23973, "Do you trust the authors of the files in this folder?")),
+                    message: ( localize(26933, "Do you trust the authors of the files in this folder?")),
                     buttons: [{
-                        label: ( localize(23974, "&&Trust Folder & Continue")),
+                        label: ( localize(26934, "&&Trust Folder & Continue")),
                         run: () => this.workspaceTrustRequestService.completeResourcesTrustRequest(options.uri, WorkspaceTrustUriResponse.Open)
                     }],
                     cancelButton: {
@@ -212,22 +212,22 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
         this._register(
             this.workspaceTrustRequestService.onDidInitiateWorkspaceTrustRequest(async requestOptions => {
                 await this.workspaceTrustManagementService.workspaceResolved;
-                const message = this.useWorkspaceLanguage ? ( localize(23975, "Do you trust the authors of the files in this workspace?")) : ( localize(23976, "Do you trust the authors of the files in this folder?"));
+                const message = this.useWorkspaceLanguage ? ( localize(26935, "Do you trust the authors of the files in this workspace?")) : ( localize(26936, "Do you trust the authors of the files in this folder?"));
                 const defaultDetails = ( localize(
-                    23977,
+                    26937,
                     "A feature you are trying to use may be a security risk if you do not trust the source of the files or folders you currently have open."
                 ));
                 const details = requestOptions?.message ?? defaultDetails;
                 const buttons = requestOptions?.buttons ?? [{
-                    label: this.useWorkspaceLanguage ? ( localize(23978, "&&Trust Workspace & Continue")) : ( localize(23979, "&&Trust Folder & Continue")),
+                    label: this.useWorkspaceLanguage ? ( localize(26938, "&&Trust Workspace & Continue")) : ( localize(26939, "&&Trust Folder & Continue")),
                     type: "ContinueWithTrust"
                 }, {
-                    label: ( localize(23980, "&&Manage")),
+                    label: ( localize(26940, "&&Manage")),
                     type: "Manage"
                 }];
                 if (!( buttons.some(b => b.type === "Cancel"))) {
                     buttons.push({
-                        label: ( localize(23981, "Cancel")),
+                        label: ( localize(26941, "Cancel")),
                         type: "Cancel"
                     });
                 }
@@ -235,7 +235,7 @@ let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Di
                     markdown: ( new MarkdownString(details))
                 }, {
                     markdown: ( new MarkdownString(( localize(
-                        23982,
+                        26942,
                         "If you don't trust the authors of these files, we do not recommend continuing as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
                     ))))
                 }];
@@ -361,7 +361,7 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
                     );
                     if (!addedFoldersTrustInfo.map(info => info.trusted).every(trusted => trusted)) {
                         let detail = ( localize(
-                            23983,
+                            26943,
                             "You are adding files that are not currently trusted to a trusted workspace. Do you trust the authors of these new files?"
                         ));
                         const sessionsTrustNote = getSessionsWindowTrustNote(this.environmentService, this.productService, false);
@@ -372,9 +372,9 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
                             confirmed
                         } = await this.dialogService.confirm({
                             type: Severity.Info,
-                            message: ( localize(23984, "Do you trust the authors of the files in this folder?")),
+                            message: ( localize(26944, "Do you trust the authors of the files in this folder?")),
                             detail,
-                            cancelButton: ( localize(23985, "No")),
+                            cancelButton: ( localize(26945, "No")),
                             custom: {
                                 icon: Codicon.shield
                             }
@@ -403,25 +403,25 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
                 } else {
                     console.warn("AI generated workspace trust dialog contents not available.");
                 }
-                const title = titleString ?? (this.useWorkspaceLanguage ? ( localize(23975, "Do you trust the authors of the files in this workspace?")) : ( localize(23976, "Do you trust the authors of the files in this folder?")));
+                const title = titleString ?? (this.useWorkspaceLanguage ? ( localize(26935, "Do you trust the authors of the files in this workspace?")) : ( localize(26936, "Do you trust the authors of the files in this folder?")));
                 let checkboxText;
                 const workspaceIdentifier = toWorkspaceIdentifier(this.workspaceContextService.getWorkspace());
                 const isSingleFolderWorkspace = isSingleFolderWorkspaceIdentifier(workspaceIdentifier);
                 const isEmptyWindow = isEmptyWorkspaceIdentifier(workspaceIdentifier);
                 if (!isAiGeneratedWorkspace && this.workspaceTrustManagementService.canSetParentFolderTrust()) {
                     const name = basename(dirname(workspaceIdentifier.uri));
-                    checkboxText = ( localize(23986, "Trust the authors of all files in the parent folder '{0}'", name));
+                    checkboxText = ( localize(26946, "Trust the authors of all files in the parent folder '{0}'", name));
                 }
                 const markdownStrings = [!isSingleFolderWorkspace ? ( localize(
-                    23987,
+                    26947,
                     "{0} provides features that may automatically execute files in this workspace.",
                     this.productService.nameShort
                 )) : ( localize(
-                    23988,
+                    26948,
                     "{0} provides features that may automatically execute files in this folder.",
                     this.productService.nameShort
                 )), learnMoreString ?? ( localize(
-                    23989,
+                    26949,
                     "If you don't trust the authors of these files, we recommend to continue in restricted mode as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
                 )), !isEmptyWindow ? `\`${this.labelService.getWorkspaceLabel(workspaceIdentifier, {
     verbose: Verbosity.LONG
@@ -431,11 +431,11 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
                     markdownStrings.push(sessionsTrustNote);
                 }
                 this.doShowModal(title, {
-                    label: trustOption ?? ( localize(23990, "&&Yes, I trust the authors")),
-                    sublabel: isSingleFolderWorkspace ? ( localize(23991, "Trust folder and enable all features")) : ( localize(23992, "Trust workspace and enable all features"))
+                    label: trustOption ?? ( localize(26950, "&&Yes, I trust the authors")),
+                    sublabel: isSingleFolderWorkspace ? ( localize(26951, "Trust folder and enable all features")) : ( localize(26952, "Trust workspace and enable all features"))
                 }, {
-                    label: dontTrustOption ?? ( localize(23993, "&&No, I don't trust the authors")),
-                    sublabel: isSingleFolderWorkspace ? ( localize(23994, "Open folder in restricted mode")) : ( localize(23995, "Open workspace in restricted mode"))
+                    label: dontTrustOption ?? ( localize(26953, "&&No, I don't trust the authors")),
+                    sublabel: isSingleFolderWorkspace ? ( localize(26954, "Open folder in restricted mode")) : ( localize(26955, "Open workspace in restricted mode"))
                 }, markdownStrings, checkboxText);
             })
         );
@@ -558,10 +558,10 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
             return undefined;
         }
         const actions = [{
-            label: ( localize(23996, "Manage")),
+            label: ( localize(26956, "Manage")),
             href: "command:" + MANAGE_TRUST_COMMAND_ID
         }, {
-            label: ( localize(23997, "Learn More")),
+            label: ( localize(26957, "Learn More")),
             href: "https://aka.ms/vscode-workspace-trust"
         }];
         return {
@@ -586,17 +586,17 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
         switch (this.workspaceContextService.getWorkbenchState()) {
         case WorkbenchState.EMPTY:
             return localize(
-                23998,
+                26958,
                 "Restricted Mode is intended for safe code browsing. Trust this window to enable all features. Use navigation keys to access banner actions."
             );
         case WorkbenchState.FOLDER:
             return localize(
-                23999,
+                26959,
                 "Restricted Mode is intended for safe code browsing. Trust this folder to enable all features. Use navigation keys to access banner actions."
             );
         case WorkbenchState.WORKSPACE:
             return localize(
-                24000,
+                26960,
                 "Restricted Mode is intended for safe code browsing. Trust this workspace to enable all features. Use navigation keys to access banner actions."
             );
         }
@@ -605,17 +605,17 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
         switch (this.workspaceContextService.getWorkbenchState()) {
         case WorkbenchState.EMPTY:
             return localize(
-                24001,
+                26961,
                 "Restricted Mode is intended for safe code browsing. Trust this window to enable all features."
             );
         case WorkbenchState.FOLDER:
             return localize(
-                24002,
+                26962,
                 "Restricted Mode is intended for safe code browsing. Trust this folder to enable all features."
             );
         case WorkbenchState.WORKSPACE:
             return localize(
-                24003,
+                26963,
                 "Restricted Mode is intended for safe code browsing. Trust this workspace to enable all features."
             );
         }
@@ -634,12 +634,12 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
         case WorkbenchState.EMPTY:
             {
                 ariaLabel = ( localize(
-                    24004,
+                    26964,
                     "Restricted Mode: Some features are disabled because this window is not trusted."
                 ));
                 toolTip = {
                     value: ( localize(
-                        24005,
+                        26965,
                         "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [window is not trusted]({1}).",
                         `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
                         `command:${MANAGE_TRUST_COMMAND_ID}`
@@ -652,12 +652,12 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
         case WorkbenchState.FOLDER:
             {
                 ariaLabel = ( localize(
-                    24006,
+                    26966,
                     "Restricted Mode: Some features are disabled because this folder is not trusted."
                 ));
                 toolTip = {
                     value: ( localize(
-                        24007,
+                        26967,
                         "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [folder is not trusted]({1}).",
                         `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
                         `command:${MANAGE_TRUST_COMMAND_ID}`
@@ -670,12 +670,12 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
         case WorkbenchState.WORKSPACE:
             {
                 ariaLabel = ( localize(
-                    24008,
+                    26968,
                     "Restricted Mode: Some features are disabled because this workspace is not trusted."
                 ));
                 toolTip = {
                     value: ( localize(
-                        24009,
+                        26969,
                         "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [workspace is not trusted]({1}).",
                         `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
                         `command:${MANAGE_TRUST_COMMAND_ID}`
@@ -687,8 +687,8 @@ let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
             }
         }
         return {
-            name: ( localize(24010, "Workspace Trust")),
-            text: `$(shield) ${( localize(24011, "Restricted Mode"))}`,
+            name: ( localize(26970, "Workspace Trust")),
+            text: `$(shield) ${( localize(26971, "Restricted Mode"))}`,
             ariaLabel: ariaLabel,
             tooltip: toolTip,
             command: MANAGE_TRUST_COMMAND_ID,
@@ -732,16 +732,16 @@ class WorkspaceTrustEditorInputSerializer {
 }
 ( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(WorkspaceTrustEditorInput.ID, WorkspaceTrustEditorInputSerializer);
 ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
-    EditorPaneDescriptor.create(WorkspaceTrustEditor, WorkspaceTrustEditor.ID, ( localize(24012, "Workspace Trust Editor"))),
+    EditorPaneDescriptor.create(WorkspaceTrustEditor, WorkspaceTrustEditor.ID, ( localize(26972, "Workspace Trust Editor"))),
     [( new SyncDescriptor(WorkspaceTrustEditorInput))]
 );
 const CONFIGURE_TRUST_COMMAND_ID = "workbench.trust.configure";
-const WORKSPACES_CATEGORY = ( localize2(24013, "Workspaces"));
+const WORKSPACES_CATEGORY = ( localize2(26973, "Workspaces"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: CONFIGURE_TRUST_COMMAND_ID,
-            title: ( localize2(24014, "Configure Workspace Trust Settings")),
+            title: ( localize2(26974, "Configure Workspace Trust Settings")),
             precondition: ( ContextKeyExpr.and(WorkspaceTrustContext.IsEnabled, ( ContextKeyExpr.equals(`config.${WORKSPACE_TRUST_ENABLED}`, true)))),
             category: WORKSPACES_CATEGORY,
             f1: true
@@ -758,7 +758,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: MANAGE_TRUST_COMMAND_ID,
-            title: ( localize2(24015, "Manage Workspace Trust")),
+            title: ( localize2(26975, "Manage Workspace Trust")),
             precondition: ( ContextKeyExpr.and(WorkspaceTrustContext.IsEnabled, ( ContextKeyExpr.equals(`config.${WORKSPACE_TRUST_ENABLED}`, true)))),
             category: WORKSPACES_CATEGORY,
             f1: true
@@ -781,7 +781,7 @@ registerAction2(class extends Action2 {
             type: "boolean",
             default: true,
             description: ( localize(
-                24016,
+                26976,
                 "Controls whether or not Workspace Trust is enabled within VS Code."
             )),
             tags: [WORKSPACE_TRUST_SETTING_TAG],
@@ -790,29 +790,29 @@ registerAction2(class extends Action2 {
         [WORKSPACE_TRUST_STARTUP_PROMPT]: {
             type: "string",
             default: "never",
-            description: ( localize(24017, "Controls when the startup prompt to trust a workspace is shown.")),
+            description: ( localize(26977, "Controls when the startup prompt to trust a workspace is shown.")),
             tags: [WORKSPACE_TRUST_SETTING_TAG],
             scope: ConfigurationScope.APPLICATION,
             enum: ["always", "once", "never"],
-            enumDescriptions: [( localize(24018, "Ask for trust every time an untrusted workspace is opened.")), ( localize(24019, "Ask for trust the first time an untrusted workspace is opened.")), ( localize(24020, "Do not ask for trust when an untrusted workspace is opened."))]
+            enumDescriptions: [( localize(26978, "Ask for trust every time an untrusted workspace is opened.")), ( localize(26979, "Ask for trust the first time an untrusted workspace is opened.")), ( localize(26980, "Do not ask for trust when an untrusted workspace is opened."))]
         },
         [WORKSPACE_TRUST_BANNER]: {
             type: "string",
             default: "untilDismissed",
-            description: ( localize(24021, "Controls when the restricted mode banner is shown.")),
+            description: ( localize(26981, "Controls when the restricted mode banner is shown.")),
             tags: [WORKSPACE_TRUST_SETTING_TAG],
             scope: ConfigurationScope.APPLICATION,
             enum: ["always", "untilDismissed", "never"],
-            enumDescriptions: [( localize(24022, "Show the banner every time an untrusted workspace is open.")), ( localize(
-                24023,
+            enumDescriptions: [( localize(26982, "Show the banner every time an untrusted workspace is open.")), ( localize(
+                26983,
                 "Show the banner when an untrusted workspace is opened until dismissed."
-            )), ( localize(24024, "Do not show the banner when an untrusted workspace is open."))]
+            )), ( localize(26984, "Do not show the banner when an untrusted workspace is open."))]
         },
         [WORKSPACE_TRUST_UNTRUSTED_FILES]: {
             type: "string",
             default: "prompt",
             markdownDescription: ( localize(
-                24025,
+                26985,
                 "Controls how to handle opening untrusted files in a trusted workspace. This setting also applies to opening files in an empty window which is trusted via `#{0}#`.",
                 WORKSPACE_TRUST_EMPTY_WINDOW
             )),
@@ -820,13 +820,13 @@ registerAction2(class extends Action2 {
             scope: ConfigurationScope.APPLICATION,
             enum: ["prompt", "open", "newWindow"],
             enumDescriptions: [( localize(
-                24026,
+                26986,
                 "Ask how to handle untrusted files for each workspace. Once untrusted files are introduced to a trusted workspace, you will not be prompted again."
             )), ( localize(
-                24027,
+                26987,
                 "Always allow untrusted files to be introduced to a trusted workspace without prompting."
             )), ( localize(
-                24028,
+                26988,
                 "Always open untrusted files in a separate window in restricted mode without prompting."
             ))]
         },
@@ -834,7 +834,7 @@ registerAction2(class extends Action2 {
             type: "boolean",
             default: true,
             markdownDescription: ( localize(
-                24029,
+                26989,
                 "Controls whether or not the empty window is trusted by default within VS Code. When used with `#{0}#`, you can enable the full functionality of VS Code without prompting in an empty window.",
                 WORKSPACE_TRUST_UNTRUSTED_FILES
             )),

package/vscode/src/vs/workbench/contrib/workspace/browser/workspaceTrustEditor.d.ts

@@ -1,6 +1,13 @@
 import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { IMessage } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox";
+import { DomScrollableElement } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
@@ -12,6 +19,7 @@ import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workb
 import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
 import { IWorkbenchConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/configuration.service";
 import { IExtensionManifestPropertiesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 import { WorkspaceTrustEditorInput } from "../../../services/workspaces/browser/workspaceTrustEditorInput.js";
 import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
 import { IWorkbenchExtensionEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service";
@@ -19,6 +27,48 @@ import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
 import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
 export declare const shieldIcon: ThemeIcon;
+interface ITrustedUriItem {
+    parentOfWorkspaceItem: boolean;
+    uri: URI;
+}
+export declare class WorkspaceTrustedUrisTable extends Disposable {
+    private readonly container;
+    private readonly scrollableElement;
+    private readonly instantiationService;
+    private readonly workspaceService;
+    private readonly workspaceTrustManagementService;
+    private readonly uriService;
+    private readonly labelService;
+    private readonly fileDialogService;
+    private readonly _onDidAcceptEdit;
+    readonly onDidAcceptEdit: Event<ITrustedUriItem>;
+    private readonly _onDidRejectEdit;
+    readonly onDidRejectEdit: Event<ITrustedUriItem>;
+    private _onEdit;
+    readonly onEdit: Event<ITrustedUriItem>;
+    private _onDelete;
+    readonly onDelete: Event<ITrustedUriItem>;
+    private readonly table;
+    private readonly descriptionElement;
+    constructor(container: HTMLElement, scrollableElement: DomScrollableElement | undefined, instantiationService: IInstantiationService, workspaceService: IWorkspaceContextService, workspaceTrustManagementService: IWorkspaceTrustManagementService, uriService: IUriIdentityService, labelService: ILabelService, fileDialogService: IFileDialogService);
+    private addTrustedUri;
+    private getIndexOfTrustedUriEntry;
+    private selectTrustedUriEntry;
+    /**
+     * The table is laid out to fit all of its rows, so scrolling happens in the surrounding
+     * scrollable element rather than in the table itself.
+     */
+    private revealInScrollableElement;
+    private get currentWorkspaceUri();
+    private get trustedUriEntries();
+    layout(): void;
+    updateTable(): void;
+    validateUri(path: string, item?: ITrustedUriItem): IMessage | null;
+    acceptEdit(item: ITrustedUriItem, uri: URI): Promise<void>;
+    rejectEdit(item: ITrustedUriItem): void;
+    delete(item: ITrustedUriItem): Promise<void>;
+    edit(item: ITrustedUriItem, usePickerIfPossible?: boolean): Promise<void>;
+}
 export declare class WorkspaceTrustEditor extends EditorPane {
     private readonly workspaceService;
     private readonly extensionWorkbenchService;
@@ -53,6 +103,7 @@ export declare class WorkspaceTrustEditor extends EditorPane {
     private getFeaturesHeaderText;
     private rendering;
     private readonly rerenderDisposables;
+    private readonly actionButtons;
     private render;
     private getExtensionCount;
     private createHeaderElement;
@@ -68,3 +119,4 @@ export declare class WorkspaceTrustEditor extends EditorPane {
     private layoutParticipants;
     layout(dimension: Dimension): void;
 }
+export {};

package/vscode/src/vs/workbench/contrib/workspace/browser/workspaceTrustEditor.js

@@ -8,6 +8,7 @@ import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/bas
 import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { debounce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/decorators';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { KeyCode, KeyMod } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
 import { normalizeDriveLetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
@@ -31,6 +32,7 @@ import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/confettiColors';
 import { editorErrorForeground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
 import { buttonBackground, buttonSecondaryBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
@@ -65,15 +67,16 @@ import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
 
 var TrustedUriActionsColumnRenderer_1, TrustedUriPathColumnRenderer_1, TrustedUriHostColumnRenderer_1, WorkspaceTrustEditor_1;
-const shieldIcon = registerIcon("workspace-trust-banner", Codicon.shield, ( localize(24030, "Icon for workspace trust ion the banner.")));
-const checkListIcon = registerIcon("workspace-trust-editor-check", Codicon.check, ( localize(24031, "Icon for the checkmark in the workspace trust editor.")));
-const xListIcon = registerIcon("workspace-trust-editor-cross", Codicon.x, ( localize(24032, "Icon for the cross in the workspace trust editor.")));
-const folderPickerIcon = registerIcon("workspace-trust-editor-folder-picker", Codicon.folder, ( localize(24033, "Icon for the pick folder icon in the workspace trust editor.")));
-const editIcon = registerIcon("workspace-trust-editor-edit-folder", Codicon.edit, ( localize(24034, "Icon for the edit folder icon in the workspace trust editor.")));
-const removeIcon = registerIcon("workspace-trust-editor-remove-folder", Codicon.close, ( localize(24035, "Icon for the remove folder icon in the workspace trust editor.")));
+const shieldIcon = registerIcon("workspace-trust-banner", Codicon.shield, ( localize(26990, "Icon for workspace trust ion the banner.")));
+const checkListIcon = registerIcon("workspace-trust-editor-check", Codicon.check, ( localize(26991, "Icon for the checkmark in the workspace trust editor.")));
+const xListIcon = registerIcon("workspace-trust-editor-cross", Codicon.x, ( localize(26992, "Icon for the cross in the workspace trust editor.")));
+const folderPickerIcon = registerIcon("workspace-trust-editor-folder-picker", Codicon.folder, ( localize(26993, "Icon for the pick folder icon in the workspace trust editor.")));
+const editIcon = registerIcon("workspace-trust-editor-edit-folder", Codicon.edit, ( localize(26994, "Icon for the edit folder icon in the workspace trust editor.")));
+const removeIcon = registerIcon("workspace-trust-editor-remove-folder", Codicon.close, ( localize(26995, "Icon for the remove folder icon in the workspace trust editor.")));
 let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposable {
     constructor(
         container,
+        scrollableElement,
         instantiationService,
         workspaceService,
         workspaceTrustManagementService,
@@ -83,6 +86,7 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
     ) {
         super();
         this.container = container;
+        this.scrollableElement = scrollableElement;
         this.instantiationService = instantiationService;
         this.workspaceService = workspaceService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
@@ -100,62 +104,64 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
         this.descriptionElement = container.appendChild($(".workspace-trusted-folders-description"));
         const tableElement = container.appendChild($(".trusted-uris-table"));
         const addButtonBarElement = container.appendChild($(".trusted-uris-button-bar"));
-        this.table = this.instantiationService.createInstance(WorkbenchTable, "WorkspaceTrust", tableElement, ( new TrustedUriTableVirtualDelegate()), [{
-            label: ( localize(24036, "Host")),
-            tooltip: "",
-            weight: 1,
-            templateId: TrustedUriHostColumnRenderer.TEMPLATE_ID,
-            project(row) {
-                return row;
-            }
-        }, {
-            label: ( localize(24037, "Path")),
-            tooltip: "",
-            weight: 8,
-            templateId: TrustedUriPathColumnRenderer.TEMPLATE_ID,
-            project(row) {
-                return row;
-            }
-        }, {
-            label: "",
-            tooltip: "",
-            weight: 1,
-            minimumWidth: 75,
-            maximumWidth: 75,
-            templateId: TrustedUriActionsColumnRenderer.TEMPLATE_ID,
-            project(row) {
-                return row;
-            }
-        }], [
-            this.instantiationService.createInstance(TrustedUriHostColumnRenderer),
-            this.instantiationService.createInstance(TrustedUriPathColumnRenderer, this),
-            this.instantiationService.createInstance(TrustedUriActionsColumnRenderer, this, this.currentWorkspaceUri)
-        ], {
-            horizontalScrolling: false,
-            alwaysConsumeMouseWheel: false,
-            openOnSingleClick: false,
-            multipleSelectionSupport: false,
-            accessibilityProvider: {
-                getAriaLabel: item => {
-                    const hostLabel = getHostLabel(this.labelService, item);
-                    if (hostLabel === undefined || hostLabel.length === 0) {
-                        return localize(24038, "{0}, trusted", this.labelService.getUriLabel(item.uri));
-                    }
-                    return localize(
-                        24039,
-                        "{0} on {1}, trusted",
-                        this.labelService.getUriLabel(item.uri),
-                        hostLabel
-                    );
+        this.table = this._register(
+            this.instantiationService.createInstance(WorkbenchTable, "WorkspaceTrust", tableElement, ( new TrustedUriTableVirtualDelegate()), [{
+                label: ( localize(26996, "Host")),
+                tooltip: "",
+                weight: 1,
+                templateId: TrustedUriHostColumnRenderer.TEMPLATE_ID,
+                project(row) {
+                    return row;
+                }
+            }, {
+                label: ( localize(26997, "Path")),
+                tooltip: "",
+                weight: 8,
+                templateId: TrustedUriPathColumnRenderer.TEMPLATE_ID,
+                project(row) {
+                    return row;
+                }
+            }, {
+                label: "",
+                tooltip: "",
+                weight: 1,
+                minimumWidth: 75,
+                maximumWidth: 75,
+                templateId: TrustedUriActionsColumnRenderer.TEMPLATE_ID,
+                project(row) {
+                    return row;
+                }
+            }], [
+                this.instantiationService.createInstance(TrustedUriHostColumnRenderer),
+                this.instantiationService.createInstance(TrustedUriPathColumnRenderer, this),
+                this.instantiationService.createInstance(TrustedUriActionsColumnRenderer, this, this.currentWorkspaceUri)
+            ], {
+                horizontalScrolling: false,
+                alwaysConsumeMouseWheel: false,
+                openOnSingleClick: false,
+                multipleSelectionSupport: false,
+                accessibilityProvider: {
+                    getAriaLabel: item => {
+                        const hostLabel = getHostLabel(this.labelService, item);
+                        if (hostLabel === undefined || hostLabel.length === 0) {
+                            return localize(26998, "{0}, trusted", this.labelService.getUriLabel(item.uri));
+                        }
+                        return localize(
+                            26999,
+                            "{0} on {1}, trusted",
+                            this.labelService.getUriLabel(item.uri),
+                            hostLabel
+                        );
+                    },
+                    getWidgetAriaLabel: () => ( localize(27000, "Trusted Folders & Workspaces"))
                 },
-                getWidgetAriaLabel: () => ( localize(24040, "Trusted Folders & Workspaces"))
-            },
-            identityProvider: {
-                getId(element) {
-                    return ( element.uri.toString());
+                identityProvider: {
+                    getId(element) {
+                        return ( element.uri.toString());
+                    }
                 }
-            }
-        });
+            })
+        );
         this._register(this.table.onDidOpen(item => {
             if (item && item.element && !item.browserEvent?.defaultPrevented) {
                 this.edit(item.element, true);
@@ -163,41 +169,58 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
         }));
         const buttonBar = this._register(( new ButtonBar(addButtonBarElement)));
         const addButton = this._register(buttonBar.addButton({
-            title: ( localize(24041, "Add Folder")),
+            title: ( localize(27001, "Add Folder")),
             ...defaultButtonStyles
         }));
-        addButton.label = ( localize(24041, "Add Folder"));
+        addButton.label = ( localize(27001, "Add Folder"));
         this._register(addButton.onDidClick(async () => {
             const uri = await this.fileDialogService.showOpenDialog({
                 canSelectFiles: false,
                 canSelectFolders: true,
                 canSelectMany: false,
                 defaultUri: this.currentWorkspaceUri,
-                openLabel: ( localize(24042, "Trust Folder")),
-                title: ( localize(24043, "Select Folder To Trust"))
+                openLabel: ( localize(27002, "Trust Folder")),
+                title: ( localize(27003, "Select Folder To Trust"))
             });
-            if (uri) {
-                this.workspaceTrustManagementService.setUrisTrust(uri, true);
+            if (uri?.length) {
+                try {
+                    await this.addTrustedUri(uri[0]);
+                } catch (error) {
+                    onUnexpectedError(error);
+                }
             }
         }));
         this._register(this.workspaceTrustManagementService.onDidChangeTrustedFolders(() => {
             this.updateTable();
         }));
     }
+    async addTrustedUri(uri) {
+        await this.workspaceTrustManagementService.setUrisTrust([uri], true);
+        if (this._store.isDisposed) {
+            return;
+        }
+        const trustInfo = await this.workspaceTrustManagementService.getUriTrustInfo(uri);
+        if (this._store.isDisposed || !trustInfo.trusted) {
+            return;
+        }
+        this.selectTrustedUriEntry({
+            uri: trustInfo.uri,
+            parentOfWorkspaceItem: false
+        });
+    }
     getIndexOfTrustedUriEntry(item) {
-        const index = ( this.trustedUriEntries.indexOf(item));
-        if (index === -1) {
-            for (let i = 0; i < this.trustedUriEntries.length; i++) {
-                if (this.trustedUriEntries[i].uri === item.uri) {
-                    return i;
-                }
+        for (let i = 0; i < this.table.length; i++) {
+            if (this.uriService.extUri.isEqual(this.table.row(i).uri, item.uri)) {
+                return i;
             }
         }
-        return index;
+        return -1;
     }
     selectTrustedUriEntry(item, focus = true) {
         const index = this.getIndexOfTrustedUriEntry(item);
         if (index !== -1) {
+            this.table.reveal(index);
+            this.revealInScrollableElement(index);
             if (focus) {
                 this.table.domFocus();
                 this.table.setFocus([index]);
@@ -205,6 +228,28 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
             this.table.setSelection([index]);
         }
     }
+    revealInScrollableElement(index) {
+        if (!this.scrollableElement) {
+            return;
+        }
+        this.scrollableElement.scanDomNode();
+        const viewportTop = this.scrollableElement.getDomNode().getBoundingClientRect().top;
+        const viewportHeight = this.scrollableElement.getScrollDimensions().height;
+        const rowTop = this.table.getHTMLElement().getBoundingClientRect().top - viewportTop + TrustedUriTableVirtualDelegate.HEADER_ROW_HEIGHT + index * TrustedUriTableVirtualDelegate.ROW_HEIGHT;
+        const rowBottom = rowTop + TrustedUriTableVirtualDelegate.ROW_HEIGHT;
+        const {
+            scrollTop
+        } = this.scrollableElement.getScrollPosition();
+        if (rowTop < 0) {
+            this.scrollableElement.setScrollPosition({
+                scrollTop: scrollTop + rowTop
+            });
+        } else if (rowBottom > viewportHeight) {
+            this.scrollableElement.setScrollPosition({
+                scrollTop: scrollTop + rowBottom - viewportHeight
+            });
+        }
+    }
     get currentWorkspaceUri() {
         return this.workspaceService.getWorkspace().folders[0]?.uri || URI.file("/");
     }
@@ -257,9 +302,9 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
         const entries = this.trustedUriEntries;
         this.container.classList.toggle("empty", entries.length === 0);
         this.descriptionElement.innerText = entries.length ? ( localize(
-            24044,
+            27004,
             "You trust the following folders, their subfolders, and workspace files."
-        )) : ( localize(24045, "You haven't trusted any folders or workspace files yet."));
+        )) : ( localize(27005, "You haven't trusted any folders or workspace files yet."));
         this.table.splice(0, Number.POSITIVE_INFINITY, this.trustedUriEntries);
         this.layout();
     }
@@ -273,7 +318,7 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
                 return {
                     type: MessageType.WARNING,
                     content: ( localize(
-                        24046,
+                        27006,
                         "You will trust all repositories on {0}.",
                         getHostLabel(this.labelService, item)
                     ))
@@ -283,7 +328,7 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
                 return {
                     type: MessageType.WARNING,
                     content: ( localize(
-                        24047,
+                        27007,
                         "You will trust all repositories and forks under '{0}' on {1}.",
                         segments[0],
                         getHostLabel(this.labelService, item)
@@ -293,13 +338,13 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
             if (segments.length > 2) {
                 return {
                     type: MessageType.ERROR,
-                    content: ( localize(24048, "You cannot trust individual folders within a repository.", path))
+                    content: ( localize(27008, "You cannot trust individual folders within a repository.", path))
                 };
             }
         }
         return null;
     }
-    acceptEdit(item, uri) {
+    async acceptEdit(item, uri) {
         const trustedFolders = this.workspaceTrustManagementService.getTrustedUris();
         const index = trustedFolders.findIndex(u => this.uriService.extUri.isEqual(u, item.uri));
         if (index >= trustedFolders.length || index === -1) {
@@ -307,8 +352,14 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
         } else {
             trustedFolders[index] = uri;
         }
-        this.workspaceTrustManagementService.setTrustedUris(trustedFolders);
-        this._onDidAcceptEdit.fire(item);
+        try {
+            await this.workspaceTrustManagementService.setTrustedUris(trustedFolders);
+            if (!this._store.isDisposed) {
+                this._onDidAcceptEdit.fire(item);
+            }
+        } catch (error) {
+            onUnexpectedError(error);
+        }
     }
     rejectEdit(item) {
         this._onDidRejectEdit.fire(item);
@@ -334,8 +385,8 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
                 canSelectFolders: true,
                 canSelectMany: false,
                 defaultUri: item.uri,
-                openLabel: ( localize(24042, "Trust Folder")),
-                title: ( localize(24043, "Select Folder To Trust"))
+                openLabel: ( localize(27002, "Trust Folder")),
+                title: ( localize(27003, "Select Folder To Trust"))
             });
             if (uri) {
                 this.acceptEdit(item, uri[0]);
@@ -348,7 +399,7 @@ let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposab
         }
     }
 };
-WorkspaceTrustedUrisTable = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IWorkspaceTrustManagementService)), ( __param(4, IUriIdentityService)), ( __param(5, ILabelService)), ( __param(6, IFileDialogService))], WorkspaceTrustedUrisTable));
+WorkspaceTrustedUrisTable = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IWorkspaceTrustManagementService)), ( __param(5, IUriIdentityService)), ( __param(6, ILabelService)), ( __param(7, IFileDialogService))], WorkspaceTrustedUrisTable));
 class TrustedUriTableVirtualDelegate {
     constructor() {
         this.headerRowHeight = TrustedUriTableVirtualDelegate.HEADER_ROW_HEIGHT;
@@ -402,7 +453,7 @@ let TrustedUriActionsColumnRenderer = class TrustedUriActionsColumnRenderer {
             class: ThemeIcon.asClassName(editIcon),
             enabled: true,
             id: "editTrustedUri",
-            tooltip: ( localize(24049, "Edit Path")),
+            tooltip: ( localize(27009, "Edit Path")),
             run: () => {
                 this.table.edit(item, false);
             }
@@ -414,7 +465,7 @@ let TrustedUriActionsColumnRenderer = class TrustedUriActionsColumnRenderer {
             class: ThemeIcon.asClassName(folderPickerIcon),
             enabled: true,
             id: "pickerTrustedUri",
-            tooltip: ( localize(24050, "Open File Picker")),
+            tooltip: ( localize(27010, "Open File Picker")),
             run: () => {
                 this.table.edit(item, true);
             }
@@ -426,7 +477,7 @@ let TrustedUriActionsColumnRenderer = class TrustedUriActionsColumnRenderer {
             class: ThemeIcon.asClassName(removeIcon),
             enabled: true,
             id: "deleteTrustedUri",
-            tooltip: ( localize(24051, "Delete Path")),
+            tooltip: ( localize(27011, "Delete Path")),
             run: async () => {
                 await this.table.delete(item);
             }
@@ -452,13 +503,13 @@ let TrustedUriPathColumnRenderer = class TrustedUriPathColumnRenderer {
     renderTemplate(container) {
         const element = container.appendChild($(".path"));
         const pathLabel = element.appendChild($("div.path-label"));
-        const pathInput = ( new InputBox(element, this.contextViewService, {
+        const disposables = ( new DisposableStore());
+        const pathInput = disposables.add(( new InputBox(element, this.contextViewService, {
             validationOptions: {
                 validation: value => this.table.validateUri(value, this.currentItem)
             },
             inputBoxStyles: defaultInputBoxStyles
-        }));
-        const disposables = ( new DisposableStore());
+        })));
         const renderDisposables = disposables.add(( new DisposableStore()));
         return {
             element,
@@ -496,7 +547,6 @@ let TrustedUriPathColumnRenderer = class TrustedUriPathColumnRenderer {
             }) : item.uri.with({
                 path: pathToUse
             });
-            templateData.pathLabel.innerText = this.formatPath(uri);
             if (uri) {
                 this.table.acceptEdit(item, uri);
             }
@@ -552,7 +602,7 @@ let TrustedUriPathColumnRenderer = class TrustedUriPathColumnRenderer {
 };
 TrustedUriPathColumnRenderer = TrustedUriPathColumnRenderer_1 = ( __decorate([( __param(1, IContextViewService))], TrustedUriPathColumnRenderer));
 function getHostLabel(labelService, item) {
-    return item.uri.authority ? labelService.getHostLabel(item.uri.scheme, item.uri.authority) : ( localize(24052, "Local"));
+    return item.uri.authority ? labelService.getHostLabel(item.uri.scheme, item.uri.authority) : ( localize(27012, "Local"));
 }
 let TrustedUriHostColumnRenderer = class TrustedUriHostColumnRenderer {
     static {
@@ -636,6 +686,7 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         this.keybindingService = keybindingService;
         this.rendering = false;
         this.rerenderDisposables = this._register(( new DisposableStore()));
+        this.actionButtons = ( new Map());
         this.layoutParticipants = [];
     }
     createEditor(parent) {
@@ -649,6 +700,11 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
             vertical: ScrollbarVisibility.Auto
         })));
         append(this.rootElement, this.bodyScrollBar.getDomNode());
+        this._register(addDisposableListener(
+            scrollableContent,
+            EventType.SCROLL,
+            () => this.bodyScrollBar.scanDomNode()
+        ));
         this.createAffectedFeaturesElement(scrollableContent);
         this.createConfigurationElement(scrollableContent);
         this.rootElement.style.setProperty("--workspace-trust-selected-color", asCssVariable(buttonBackground));
@@ -684,7 +740,7 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
                 this.rootElement.focus();
             } else if (event.equals(KeyMod.CtrlCmd | KeyCode.Enter)) {
                 if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
-                    this.workspaceTrustManagementService.setWorkspaceTrust(!this.workspaceTrustManagementService.isWorkspaceTrusted());
+                    this.workspaceTrustManagementService.setWorkspaceTrust(!this.workspaceTrustManagementService.isWorkspaceTrusted()).catch(onUnexpectedError);
                 }
             }
         }));
@@ -721,18 +777,18 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
     getHeaderTitleText(trusted) {
         if (trusted) {
             if (this.workspaceTrustManagementService.isWorkspaceTrustForced()) {
-                return localize(24053, "This window is trusted");
+                return localize(27013, "This window is trusted");
             }
             switch (this.workspaceService.getWorkbenchState()) {
             case WorkbenchState.EMPTY:
-                return localize(24054, "You trust this window");
+                return localize(27014, "You trust this window");
             case WorkbenchState.FOLDER:
-                return localize(24055, "You trust this folder");
+                return localize(27015, "You trust this folder");
             case WorkbenchState.WORKSPACE:
-                return localize(24056, "You trust this workspace");
+                return localize(27016, "You trust this workspace");
             }
         }
-        return localize(24057, "You are in Restricted Mode");
+        return localize(27017, "You are in Restricted Mode");
     }
     getHeaderTitleIconClassNames(trusted) {
         return ThemeIcon.asClassNameArray(shieldIcon);
@@ -743,36 +799,36 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         switch (this.workspaceService.getWorkbenchState()) {
         case WorkbenchState.EMPTY:
             {
-                title = trusted ? ( localize(24058, "In a Trusted Window")) : ( localize(24059, "In Restricted Mode"));
+                title = trusted ? ( localize(27018, "In a Trusted Window")) : ( localize(27019, "In Restricted Mode"));
                 subTitle = trusted ? ( localize(
-                    24060,
+                    27020,
                     "You trust the authors of the files in the current window. All features are enabled:"
                 )) : ( localize(
-                    24061,
+                    27021,
                     "You do not trust the authors of the files in the current window. The following features are disabled:"
                 ));
                 break;
             }
         case WorkbenchState.FOLDER:
             {
-                title = trusted ? ( localize(24062, "In a Trusted Folder")) : ( localize(24059, "In Restricted Mode"));
+                title = trusted ? ( localize(27022, "In a Trusted Folder")) : ( localize(27019, "In Restricted Mode"));
                 subTitle = trusted ? ( localize(
-                    24063,
+                    27023,
                     "You trust the authors of the files in the current folder. All features are enabled:"
                 )) : ( localize(
-                    24064,
+                    27024,
                     "You do not trust the authors of the files in the current folder. The following features are disabled:"
                 ));
                 break;
             }
         case WorkbenchState.WORKSPACE:
             {
-                title = trusted ? ( localize(24065, "In a Trusted Workspace")) : ( localize(24059, "In Restricted Mode"));
+                title = trusted ? ( localize(27025, "In a Trusted Workspace")) : ( localize(27019, "In Restricted Mode"));
                 subTitle = trusted ? ( localize(
-                    24066,
+                    27026,
                     "You trust the authors of the files in the current workspace. All features are enabled:"
                 )) : ( localize(
-                    24067,
+                    27027,
                     "You do not trust the authors of the files in the current workspace. The following features are disabled:"
                 ));
                 break;
@@ -788,7 +844,9 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
             return;
         }
         this.rendering = true;
+        const focusedAction = Array.from(this.actionButtons).find(([, button]) => button.hasFocus())?.[0];
         this.rerenderDisposables.clear();
+        this.actionButtons.clear();
         const isWorkspaceTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
         this.rootElement.classList.toggle("trusted", isWorkspaceTrusted);
         this.rootElement.classList.toggle("untrusted", !isWorkspaceTrusted);
@@ -798,16 +856,16 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         this.headerDescription.innerText = "";
         const headerDescriptionText = append(this.headerDescription, $("div"));
         headerDescriptionText.innerText = isWorkspaceTrusted ? ( localize(
-            24068,
+            27028,
             "All features are enabled because trust has been granted to the workspace."
         )) : ( localize(
-            24069,
+            27029,
             "{0} is in a restricted mode intended for safe code browsing.",
             this.productService.nameShort
         ));
         const headerDescriptionActions = append(this.headerDescription, $("div"));
         const headerDescriptionActionsText = ( localize(
-            24070,
+            27030,
             "[Configure your settings]({0}) or [learn more](https://aka.ms/vscode-workspace-trust).",
             `command:workbench.trust.configure`
         ));
@@ -822,7 +880,7 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
             }
         }
         this.headerContainer.className = this.getHeaderContainerClass(isWorkspaceTrusted);
-        this.rootElement.setAttribute("aria-label", `${( localize(24071, "Manage Workspace Trust"))}:  ${this.headerContainer.innerText}`);
+        this.rootElement.setAttribute("aria-label", `${( localize(27031, "Manage Workspace Trust"))}:  ${this.headerContainer.innerText}`);
         const restrictedSettings = this.configurationService.restrictedSettings;
         const configurationRegistry = ( Registry.as(Extensions.Configuration));
         const settingsRequiringTrustedWorkspaceCount = restrictedSettings.default.filter(key => {
@@ -849,6 +907,9 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         this.workspaceTrustedUrisTable.updateTable();
         this.bodyScrollBar.getDomNode().style.height = `calc(100% - ${this.headerContainer.clientHeight}px)`;
         this.bodyScrollBar.scanDomNode();
+        if (focusedAction) {
+            (this.actionButtons.get(focusedAction) ?? this.headerContainer).focus();
+        }
         this.rendering = false;
     }
     getExtensionCount() {
@@ -890,9 +951,9 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
             tabIndex: "0"
         }));
         const configurationTitle = append(this.configurationContainer, $(".workspace-trusted-folders-title"));
-        configurationTitle.innerText = ( localize(24040, "Trusted Folders & Workspaces"));
+        configurationTitle.innerText = ( localize(27000, "Trusted Folders & Workspaces"));
         this.workspaceTrustedUrisTable = this._register(
-            this.instantiationService.createInstance(WorkspaceTrustedUrisTable, this.configurationContainer)
+            this.instantiationService.createInstance(WorkspaceTrustedUrisTable, this.configurationContainer, this.bodyScrollBar)
         );
     }
     createAffectedFeaturesElement(parent) {
@@ -915,7 +976,7 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         clearNode(this.untrustedContainer);
         const [trustedTitle, trustedSubTitle] = this.getFeaturesHeaderText(true);
         this.renderLimitationsHeaderElement(this.trustedContainer, trustedTitle, trustedSubTitle);
-        const trustedContainerItems = this.workspaceService.getWorkbenchState() === WorkbenchState.EMPTY ? [( localize(24072, "Tasks are allowed to run")), ( localize(24073, "Debugging is enabled")), ( localize(24074, "All enabled extensions are activated"))] : [( localize(24072, "Tasks are allowed to run")), ( localize(24073, "Debugging is enabled")), ( localize(24075, "All workspace settings are applied")), ( localize(24074, "All enabled extensions are activated"))];
+        const trustedContainerItems = this.workspaceService.getWorkbenchState() === WorkbenchState.EMPTY ? [( localize(27032, "Tasks are allowed to run")), ( localize(27033, "Debugging is enabled")), ( localize(27034, "All enabled extensions are activated"))] : [( localize(27032, "Tasks are allowed to run")), ( localize(27033, "Debugging is enabled")), ( localize(27035, "All workspace settings are applied")), ( localize(27034, "All enabled extensions are activated"))];
         this.renderLimitationsListElement(
             this.trustedContainer,
             trustedContainerItems,
@@ -923,18 +984,18 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         );
         const [untrustedTitle, untrustedSubTitle] = this.getFeaturesHeaderText(false);
         this.renderLimitationsHeaderElement(this.untrustedContainer, untrustedTitle, untrustedSubTitle);
-        const untrustedContainerItems = this.workspaceService.getWorkbenchState() === WorkbenchState.EMPTY ? [( localize(24076, "Tasks are not allowed to run")), ( localize(24077, "Debugging is disabled")), fixBadLocalizedLinks(( localize(
-            24078,
+        const untrustedContainerItems = this.workspaceService.getWorkbenchState() === WorkbenchState.EMPTY ? [( localize(27036, "Tasks are not allowed to run")), ( localize(27037, "Debugging is disabled")), fixBadLocalizedLinks(( localize(
+            27038,
             "[{0} extensions]({1}) are disabled or have limited functionality",
             numExtensions,
             `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`
-        )))] : [( localize(24076, "Tasks are not allowed to run")), ( localize(24077, "Debugging is disabled")), fixBadLocalizedLinks(numSettings ? ( localize(
-            24079,
+        )))] : [( localize(27036, "Tasks are not allowed to run")), ( localize(27037, "Debugging is disabled")), fixBadLocalizedLinks(numSettings ? ( localize(
+            27039,
             "[{0} workspace settings]({1}) are not applied",
             numSettings,
             "command:settings.filterUntrusted"
-        )) : ( localize(24080, "Workspace settings requiring trust are not applied"))), fixBadLocalizedLinks(( localize(
-            24078,
+        )) : ( localize(27040, "Workspace settings requiring trust are not applied"))), fixBadLocalizedLinks(( localize(
+            27038,
             "[{0} extensions]({1}) are disabled or have limited functionality",
             numExtensions,
             `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`
@@ -951,7 +1012,18 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
                 this.addTrustedTextToElement(this.untrustedContainer);
             }
         } else {
-            if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
+            if (!this.workspaceTrustManagementService.isWorkspaceTrustSourceResolved()) {
+                const description = append(this.trustedContainer, $(".workspace-trust-untrusted-description"));
+                description.innerText = ( localize(
+                    27041,
+                    "The source repository for this workspace could not be verified. You can keep reviewing files in Restricted Mode. Make sure the repository extension is enabled and you are signed in, then retry."
+                ));
+                this.createButtonRow(this.trustedContainer, [{
+                    action: this.rerenderDisposables.add(( new Action("workspace.trust.button.action.retry", ( localize(27042, "Retry Source Check")), undefined, true, async () => {
+                        await this.workspaceTrustManagementService.resolveWorkspaceTrust();
+                    })))
+                }]);
+            } else if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
                 this.addTrustButtonToElement(this.trustedContainer);
             }
         }
@@ -965,20 +1037,28 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
             keybinding
         } of buttonInfo) {
             const button = buttonBar.addButtonWithDescription(defaultButtonStyles);
+            this.actionButtons.set(action.id, button);
             button.label = action.label;
             button.enabled = enabled !== undefined ? enabled : action.enabled;
-            button.description = keybinding.getLabel();
-            button.element.ariaLabel = action.label + ", " + ( localize(24081, "Keyboard Shortcut: {0}", keybinding.getAriaLabel()));
-            this.rerenderDisposables.add(button.onDidClick(e => {
+            button.description = keybinding?.getLabel() ?? "";
+            button.element.ariaLabel = keybinding ? action.label + ", " + ( localize(27043, "Keyboard Shortcut: {0}", keybinding.getAriaLabel())) : action.label;
+            this.rerenderDisposables.add(button.onDidClick(async e => {
                 if (e) {
                     EventHelper.stop(e, true);
                 }
-                action.run();
+                button.enabled = false;
+                try {
+                    await action.run();
+                } catch (error) {
+                    onUnexpectedError(error);
+                } finally {
+                    button.enabled = enabled !== undefined ? enabled : action.enabled;
+                }
             }));
         }
     }
     addTrustButtonToElement(parent) {
-        const trustAction = this.rerenderDisposables.add(( new Action("workspace.trust.button.action.grant", ( localize(24082, "Trust")), undefined, true, async () => {
+        const trustAction = this.rerenderDisposables.add(( new Action("workspace.trust.button.action.grant", ( localize(27044, "Trust")), undefined, true, async () => {
             await this.workspaceTrustManagementService.setWorkspaceTrust(true);
         })));
         const trustActions = [{
@@ -989,7 +1069,7 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
     }
     addDontTrustButtonToElement(parent) {
         this.createButtonRow(parent, [{
-            action: this.rerenderDisposables.add(( new Action("workspace.trust.button.action.deny", ( localize(24083, "Don't Trust")), undefined, true, async () => {
+            action: this.rerenderDisposables.add(( new Action("workspace.trust.button.action.deny", ( localize(27045, "Don't Trust")), undefined, true, async () => {
                 await this.workspaceTrustManagementService.setWorkspaceTrust(false);
             }))),
             keybinding: this.keybindingService.resolveUserBinding(isMacintosh ? "Cmd+Enter" : "Ctrl+Enter")[0]
@@ -1002,14 +1082,14 @@ let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
         const textElement = append(parent, $(".workspace-trust-untrusted-description"));
         if (!this.workspaceTrustManagementService.isWorkspaceTrustForced()) {
             textElement.innerText = this.workspaceService.getWorkbenchState() === WorkbenchState.WORKSPACE ? ( localize(
-                24084,
+                27046,
                 "This workspace is trusted via the bolded entries in the trusted folders below."
             )) : ( localize(
-                24085,
+                27047,
                 "This folder is trusted via the bolded entries in the trusted folders below."
             ));
         } else {
-            textElement.innerText = ( localize(24086, "This window is trusted by nature of the workspace that is opened."));
+            textElement.innerText = ( localize(27048, "This window is trusted by nature of the workspace that is opened."));
         }
     }
     renderLimitationsHeaderElement(parent, headerText, subtitleText) {
@@ -1059,4 +1139,4 @@ function fixBadLocalizedLinks(badString) {
     return badString.replace(regex, "$1[$2]($3)$4");
 }
 
-export { WorkspaceTrustEditor, shieldIcon };
+export { WorkspaceTrustEditor, WorkspaceTrustedUrisTable, shieldIcon };

package/vscode/src/vs/workbench/services/workspaces/browser/workspaceTrustEditorInput.js

@@ -7,7 +7,7 @@ import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/th
 import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
 import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
 
-const WorkspaceTrustEditorIcon = registerIcon("workspace-trust-editor-label-icon", Codicon.shield, ( localize(25288, "Icon of the workspace trust editor label.")));
+const WorkspaceTrustEditorIcon = registerIcon("workspace-trust-editor-label-icon", Codicon.shield, ( localize(28259, "Icon of the workspace trust editor label.")));
 class WorkspaceTrustEditorInput extends EditorInput {
     constructor() {
         super(...arguments);
@@ -29,7 +29,7 @@ class WorkspaceTrustEditorInput extends EditorInput {
         return super.matches(otherInput) || otherInput instanceof WorkspaceTrustEditorInput;
     }
     getName() {
-        return localize(25289, "Workspace Trust");
+        return localize(28260, "Workspace Trust");
     }
     getIcon() {
         return WorkspaceTrustEditorIcon;