@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -17,9 +17,9 @@ var IRichLocation;
         range: location.range.toJSON(),
         uri: location.uri.toJSON(),
     });
-    IRichLocation.deserialize = (location) => ({
+    IRichLocation.deserialize = (uriIdentity, location) => ({
         range: Range.lift(location.range),
-        uri: URI.revive(location.uri),
+        uri: uriIdentity.asCanonicalUri(URI.revive(location.uri)),
     });
 })(IRichLocation || (IRichLocation = {})));
 var ITestErrorMessage;
@@ -32,13 +32,13 @@ var ITestErrorMessage;
         contextValue: message.contextValue,
         location: message.location && IRichLocation.serialize(message.location),
     });
-    ITestErrorMessage.deserialize = (message) => ({
+    ITestErrorMessage.deserialize = (uriIdentity, message) => ({
         message: message.message,
         type: 0 ,
         expected: message.expected,
         actual: message.actual,
         contextValue: message.contextValue,
-        location: message.location && IRichLocation.deserialize(message.location),
+        location: message.location && IRichLocation.deserialize(uriIdentity, message.location),
     });
 })(ITestErrorMessage || (ITestErrorMessage = {})));
 const getMarkId = (marker, start) => `${start ? 's' : 'e'}${marker}`;
@@ -51,18 +51,18 @@ var ITestOutputMessage;
         length: message.length,
         location: message.location && IRichLocation.serialize(message.location),
     });
-    ITestOutputMessage.deserialize = (message) => ({
+    ITestOutputMessage.deserialize = (uriIdentity, message) => ({
         message: message.message,
         type: 1 ,
         offset: message.offset,
         length: message.length,
-        location: message.location && IRichLocation.deserialize(message.location),
+        location: message.location && IRichLocation.deserialize(uriIdentity, message.location),
     });
 })(ITestOutputMessage || (ITestOutputMessage = {})));
 var ITestMessage;
 ( (function(ITestMessage) {
     ITestMessage.serialize = (message) => message.type === 0  ? ITestErrorMessage.serialize(message) : ITestOutputMessage.serialize(message);
-    ITestMessage.deserialize = (message) => message.type === 0  ? ITestErrorMessage.deserialize(message) : ITestOutputMessage.deserialize(message);
+    ITestMessage.deserialize = (uriIdentity, message) => message.type === 0  ? ITestErrorMessage.deserialize(uriIdentity, message) : ITestOutputMessage.deserialize(uriIdentity, message);
 })(ITestMessage || (ITestMessage = {})));
 var ITestTaskState;
 ( (function(ITestTaskState) {
@@ -76,10 +76,10 @@ var ITestTaskState;
         duration: state.duration,
         messages: ( state.messages.map(ITestMessage.serialize)),
     });
-    ITestTaskState.deserialize = (state) => ({
+    ITestTaskState.deserialize = (uriIdentity, state) => ({
         state: state.state,
         duration: state.duration,
-        messages: ( state.messages.map(ITestMessage.deserialize)),
+        messages: ( state.messages.map(m => ITestMessage.deserialize(uriIdentity, m))),
     });
 })(ITestTaskState || (ITestTaskState = {})));
 const testTagDelimiter = '\0';
@@ -102,13 +102,13 @@ var ITestItem;
         error: item.error,
         sortText: item.sortText
     });
-    ITestItem.deserialize = (serialized) => ({
+    ITestItem.deserialize = (uriIdentity, serialized) => ({
         extId: serialized.extId,
         label: serialized.label,
         tags: serialized.tags,
         busy: serialized.busy,
         children: undefined,
-        uri: serialized.uri ? URI.revive(serialized.uri) : undefined,
+        uri: serialized.uri ? uriIdentity.asCanonicalUri(URI.revive(serialized.uri)) : undefined,
         range: serialized.range ? Range.lift(serialized.range) : null,
         description: serialized.description,
         error: serialized.error,
@@ -121,10 +121,10 @@ var InternalTestItem;
         expand: item.expand,
         item: ITestItem.serialize(item.item)
     });
-    InternalTestItem.deserialize = (serialized) => ({
+    InternalTestItem.deserialize = (uriIdentity, serialized) => ({
         controllerId: TestId.root(serialized.item.extId),
         expand: serialized.expand,
-        item: ITestItem.deserialize(serialized.item)
+        item: ITestItem.deserialize(uriIdentity, serialized.item)
     });
 })(InternalTestItem || (InternalTestItem = {})));
 var ITestItemUpdate;
@@ -211,11 +211,11 @@ var TestResultItem;
         computedState: original.computedState,
         tasks: ( original.tasks.map(ITestTaskState.serialize)),
     });
-    TestResultItem.deserialize = (serialized) => ({
-        ...InternalTestItem.deserialize(serialized),
+    TestResultItem.deserialize = (uriIdentity, serialized) => ({
+        ...InternalTestItem.deserialize(uriIdentity, serialized),
         ownComputedState: serialized.ownComputedState,
         computedState: serialized.computedState,
-        tasks: ( serialized.tasks.map(ITestTaskState.deserialize)),
+        tasks: ( serialized.tasks.map(m => ITestTaskState.deserialize(uriIdentity, m))),
         retired: true,
     });
 })(TestResultItem || (TestResultItem = {})));
@@ -236,12 +236,12 @@ var IFileCoverage;
         details: original.details?.map(CoverageDetails.serialize),
         uri: original.uri.toJSON(),
     });
-    IFileCoverage.deserialize = (serialized) => ({
+    IFileCoverage.deserialize = (uriIdentity, serialized) => ({
         statement: serialized.statement,
         branch: serialized.branch,
         function: serialized.function,
         details: serialized.details?.map(CoverageDetails.deserialize),
-        uri: ( URI.from(serialized.uri)),
+        uri: uriIdentity.asCanonicalUri(URI.revive(serialized.uri)),
     });
 })(IFileCoverage || (IFileCoverage = {})));
 function serializeThingWithLocation(serialized) {
@@ -283,15 +283,15 @@ var IStatementCoverage;
 })(IStatementCoverage || (IStatementCoverage = {})));
 var TestsDiffOp;
 ( (function(TestsDiffOp) {
-    TestsDiffOp.deserialize = (u) => {
+    TestsDiffOp.deserialize = (uriIdentity, u) => {
         if (u.op === 0 ) {
-            return { op: u.op, item: InternalTestItem.deserialize(u.item) };
+            return { op: u.op, item: InternalTestItem.deserialize(uriIdentity, u.item) };
         }
         else if (u.op === 1 ) {
             return { op: u.op, item: ITestItemUpdate.deserialize(u.item) };
         }
         else if (u.op === 2 ) {
-            return { op: u.op, uri: URI.revive(u.uri), docv: u.docv };
+            return { op: u.op, uri: uriIdentity.asCanonicalUri(URI.revive(u.uri)), docv: u.docv };
         }
         else {
             return u;
@@ -310,7 +310,8 @@ var TestsDiffOp;
     };
 })(TestsDiffOp || (TestsDiffOp = {})));
 class AbstractIncrementalTestCollection {
-    constructor() {
+    constructor(uriIdentity) {
+        this.uriIdentity = uriIdentity;
         this._tags = ( new Map());
         this.items = ( new Map());
         this.roots = ( new Set());
@@ -323,7 +324,7 @@ class AbstractIncrementalTestCollection {
         for (const op of diff) {
             switch (op.op) {
                 case 0 :
-                    this.add(InternalTestItem.deserialize(op.item), changes);
+                    this.add(InternalTestItem.deserialize(this.uriIdentity, op.item), changes);
                     break;
                 case 1 :
                     this.update(ITestItemUpdate.deserialize(op.item), changes);

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.js

@@ -20,7 +20,7 @@ import { parseLinkedText } from '../../../../base/common/linkedText.js';
 import { walkthroughsExtensionPoint } from './gettingStartedExtensionPoint.js';
 import { dirname } from '../../../../base/common/path.js';
 import { coalesce, flatten } from '../../../../base/common/arrays.js';
-import { IViewsService } from '../../../common/views.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
 import { checkGlobFileExists } from '../../../services/extensions/common/workspaceContains.js';

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { flatten } from '../../../../base/common/arrays.js';
+import { fromNow } from '../../../../base/common/date.js';
 import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, MutableDisposable, dispose } from '../../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable, DisposableMap, isDisposable, dispose, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from '../../../../base/common/strings.js';
 import { isString } from '../../../../base/common/types.js';
 import { localizeWithPath } from '../../../../nls.js';
@@ -144,7 +144,7 @@ let placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext,
     },
 }));
 let AuthenticationService = class AuthenticationService extends Disposable {
-    constructor(activityService, extensionService, storageService, dialogService, quickInputService, productService) {
+    constructor(activityService, extensionService, storageService, dialogService, quickInputService, productService, environmentService) {
         super();
         this.activityService = activityService;
         this.extensionService = extensionService;
@@ -156,6 +156,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         this._sessionAccessRequestItems = ( new Map());
         this._accountBadgeDisposable = this._register(( new MutableDisposable()));
         this._authenticationProviders = ( new Map());
+        this._authenticationProviderDisposables = this._register(( new DisposableMap()));
         this.declaredProviders = [];
         this._onDidRegisterAuthenticationProvider = this._register(( new Emitter()));
         this.onDidRegisterAuthenticationProvider = this._onDidRegisterAuthenticationProvider.event;
@@ -165,6 +166,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         this.onDidChangeSessions = this._onDidChangeSessions.event;
         this._onDidChangeDeclaredProviders = this._register(( new Emitter()));
         this.onDidChangeDeclaredProviders = this._onDidChangeDeclaredProviders.event;
+        environmentService.options?.authenticationProviders?.forEach(provider => this.registerAuthenticationProvider(provider.id, provider));
         authenticationExtPoint.setHandler((extensions, { added, removed }) => {
             added.forEach(point => {
                 for (const provider of point.value) {
@@ -197,7 +199,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                     }
                 }
             });
-            const removedExtPoints = flatten(( removed.map(r => r.value)));
+            const removedExtPoints = removed.flatMap(r => r.value);
             removedExtPoints.forEach(point => {
                 const index = this.declaredProviders.findIndex(provider => provider.id === point.id);
                 if (index > -1) {
@@ -219,6 +221,12 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerAuthenticationProvider(id, authenticationProvider) {
         this._authenticationProviders.set(id, authenticationProvider);
+        const disposableStore = ( new DisposableStore());
+        disposableStore.add(authenticationProvider.onDidChangeSessions(e => this.sessionsUpdate(authenticationProvider, e)));
+        if (isDisposable(authenticationProvider)) {
+            disposableStore.add(authenticationProvider);
+        }
+        this._authenticationProviderDisposables.set(id, disposableStore);
         this._onDidRegisterAuthenticationProvider.fire({ id, label: authenticationProvider.label });
         if (placeholderMenuItem) {
             placeholderMenuItem.dispose();
@@ -228,7 +236,6 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     unregisterAuthenticationProvider(id) {
         const provider = this._authenticationProviders.get(id);
         if (provider) {
-            provider.dispose();
             this._authenticationProviders.delete(id);
             this._onDidUnregisterAuthenticationProvider.fire({ id, label: provider.label });
             const accessRequests = this._sessionAccessRequestItems.get(id) || {};
@@ -236,6 +243,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                 this.removeAccessRequest(id, extensionId);
             });
         }
+        this._authenticationProviderDisposables.deleteAndDispose(id);
         if (!this._authenticationProviders.size) {
             placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
                 command: {
@@ -250,18 +258,15 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             }));
         }
     }
-    async sessionsUpdate(id, event) {
-        const provider = this._authenticationProviders.get(id);
-        if (provider) {
-            this._onDidChangeSessions.fire({ providerId: id, label: provider.label, event: event });
-            if (event.added) {
-                await this.updateNewSessionRequests(provider, event.added);
-            }
-            if (event.removed) {
-                await this.updateAccessRequests(id, event.removed);
-            }
-            this.updateBadgeCount();
+    async sessionsUpdate(provider, event) {
+        this._onDidChangeSessions.fire({ providerId: provider.id, label: provider.label, event });
+        if (event.added?.length) {
+            await this.updateNewSessionRequests(provider, event.added);
         }
+        if (event.removed?.length) {
+            await this.updateAccessRequests(provider.id, event.removed);
+        }
+        this.updateBadgeCount();
     }
     async updateNewSessionRequests(provider, addedSessions) {
         const existingRequestsForProvider = this._signInRequestItems.get(provider.id);
@@ -654,21 +659,113 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     async manageTrustedExtensionsForAccount(id, accountName) {
         const authProvider = this._authenticationProviders.get(id);
-        if (authProvider) {
-            return authProvider.manageTrustedExtensions(accountName);
-        }
-        else {
+        if (!authProvider) {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
+        const allowedExtensions = readAllowedExtensions(this.storageService, authProvider.id, accountName);
+        if (!allowedExtensions.length) {
+            this.dialogService.info(( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationService',
+                'noTrustedExtensions',
+                "This account has not been used by any extensions."
+            )));
+            return;
+        }
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.canSelectMany = true;
+        quickPick.customButton = true;
+        quickPick.customLabel = ( localizeWithPath(
+            'vs/workbench/services/authentication/browser/authenticationService',
+            'manageTrustedExtensions.cancel',
+            'Cancel'
+        ));
+        const usages = readAccountUsages(this.storageService, authProvider.id, accountName);
+        const items = ( allowedExtensions.map(extension => {
+            const usage = usages.find(usage => extension.id === usage.extensionId);
+            return {
+                label: extension.name,
+                description: usage
+                    ? ( localizeWithPath(
+                    'vs/workbench/services/authentication/browser/authenticationService',
+                    { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
+                    "Last used this account {0}",
+                    fromNow(usage.lastUsed, true)
+                ))
+                    : ( localizeWithPath(
+                    'vs/workbench/services/authentication/browser/authenticationService',
+                    'notUsed',
+                    "Has not used this account"
+                )),
+                extension
+            };
+        }));
+        quickPick.items = items;
+        quickPick.selectedItems = items.filter(item => item.extension.allowed === undefined || item.extension.allowed);
+        quickPick.title = ( localizeWithPath(
+            'vs/workbench/services/authentication/browser/authenticationService',
+            'manageTrustedExtensions',
+            "Manage Trusted Extensions"
+        ));
+        quickPick.placeholder = ( localizeWithPath(
+            'vs/workbench/services/authentication/browser/authenticationService',
+            'manageExtensions',
+            "Choose which extensions can access this account"
+        ));
+        quickPick.onDidAccept(() => {
+            const updatedAllowedList = ( quickPick.items.map(i => i.extension));
+            this.storageService.store(`${authProvider.id}-${accountName}`, JSON.stringify(updatedAllowedList), -1 , 0 );
+            quickPick.dispose();
+        });
+        quickPick.onDidChangeSelection((changed) => {
+            quickPick.items.forEach(item => {
+                if (item.extension) {
+                    item.extension.allowed = false;
+                }
+            });
+            changed.forEach((item) => item.extension.allowed = true);
+        });
+        quickPick.onDidHide(() => {
+            quickPick.dispose();
+        });
+        quickPick.onDidCustom(() => {
+            quickPick.hide();
+        });
+        quickPick.show();
     }
     async removeAccountSessions(id, accountName, sessions) {
         const authProvider = this._authenticationProviders.get(id);
-        if (authProvider) {
-            return authProvider.removeAccountSessions(accountName, sessions);
-        }
-        else {
+        if (!authProvider) {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
+        const accountUsages = readAccountUsages(this.storageService, authProvider.id, accountName);
+        const { confirmed } = await this.dialogService.confirm({
+            type: Severity.Info,
+            message: accountUsages.length
+                ? ( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationService',
+                'signOutMessage',
+                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
+                accountName,
+                ( accountUsages.map(usage => usage.extensionName)).join('\n')
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationService',
+                'signOutMessageSimple',
+                "Sign out of '{0}'?",
+                accountName
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationService',
+                { key: 'signOut', comment: ['&& denotes a mnemonic'] },
+                "&&Sign Out"
+            ))
+        });
+        if (confirmed) {
+            const removeSessionPromises = ( sessions.map(session => authProvider.removeSession(session.id)));
+            await Promise.all(removeSessionPromises);
+            removeAccountUsage(this.storageService, authProvider.id, accountName);
+            this.storageService.remove(`${authProvider.id}-${accountName}`, -1 );
+        }
     }
 };
 AuthenticationService = ( __decorate([
@@ -677,6 +774,7 @@ AuthenticationService = ( __decorate([
     ( __param(2, IStorageService)),
     ( __param(3, IDialogService)),
     ( __param(4, IQuickInputService)),
-    ( __param(5, IProductService))
+    ( __param(5, IProductService)),
+    ( __param(6, IBrowserWorkbenchEnvironmentService))
 ], AuthenticationService));
-export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo, readAccountUsages, readAllowedExtensions, removeAccountUsage };
+export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo };

package/vscode/src/vs/workbench/services/authentication/common/authentication.d.ts

@@ -0,0 +1,68 @@
+import { Event } from '../../../../base/common/event.js';
+
+interface AuthenticationSessionAccount {
+    label: string;
+    id: string;
+}
+interface AuthenticationSession {
+    id: string;
+    accessToken: string;
+    account: AuthenticationSessionAccount;
+    scopes: ReadonlyArray<string>;
+    idToken?: string;
+}
+interface AuthenticationSessionsChangeEvent {
+    added: ReadonlyArray<AuthenticationSession> | undefined;
+    removed: ReadonlyArray<AuthenticationSession> | undefined;
+    changed: ReadonlyArray<AuthenticationSession> | undefined;
+}
+interface IAuthenticationProviderCreateSessionOptions {
+    sessionToRecreate?: AuthenticationSession;
+}
+/**
+ * Represents an authentication provider.
+ */
+interface IAuthenticationProvider {
+    /**
+     * The unique identifier of the authentication provider.
+     */
+    readonly id: string;
+    /**
+     * The display label of the authentication provider.
+     */
+    readonly label: string;
+    /**
+     * Indicates whether the authentication provider supports multiple accounts.
+     */
+    readonly supportsMultipleAccounts: boolean;
+    /**
+     * An {@link Event} which fires when the array of sessions has changed, or data
+     * within a session has changed.
+     */
+    readonly onDidChangeSessions: Event<AuthenticationSessionsChangeEvent>;
+    /**
+     * Retrieves a list of authentication sessions.
+     * @param scopes - An optional list of scopes. If provided, the sessions returned should match these permissions, otherwise all sessions should be returned.
+     * @returns A promise that resolves to an array of authentication sessions.
+     */
+    getSessions(scopes?: string[]): Promise<readonly AuthenticationSession[]>;
+    /**
+     * Prompts the user to log in.
+     * If login is successful, the `onDidChangeSessions` event should be fired.
+     * If login fails, a rejected promise should be returned.
+     * If the provider does not support multiple accounts, this method should not be called if there is already an existing session matching the provided scopes.
+     * @param scopes - A list of scopes that the new session should be created with.
+     * @param options - Additional options for creating the session.
+     * @returns A promise that resolves to an authentication session.
+     */
+    createSession(scopes: string[], options: IAuthenticationProviderCreateSessionOptions): Promise<AuthenticationSession>;
+    /**
+     * Removes the session corresponding to the specified session ID.
+     * If the removal is successful, the `onDidChangeSessions` event should be fired.
+     * If a session cannot be removed, the provider should reject with an error message.
+     * @param sessionId - The ID of the session to remove.
+     */
+    removeSession(sessionId: string): Promise<void>;
+}
+
+export type { AuthenticationSession, AuthenticationSessionAccount, AuthenticationSessionsChangeEvent, IAuthenticationProvider, IAuthenticationProviderCreateSessionOptions };