@codingame/monaco-vscode-authentication-service-override 4.0.0 → 4.1.0

package/authentication.js

@@ -3,7 +3,7 @@ import { IAuthenticationService, IAuthenticationExtensionsService } from 'vscode
 import { AuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
 import { IAuthenticationAccessService, AuthenticationAccessService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationAccessService';
 import { IAuthenticationUsageService, AuthenticationUsageService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationUsageService';
-import { AuthenticationExtensionsService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationExtensionsService.js';
+import { AuthenticationExtensionsService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationExtensionsService';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-authentication-service-override",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
   }
 }

package/external/tslib/tslib.es6.js

@@ -1,11 +0,0 @@
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-export { __decorate, __param };

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,10 +0,0 @@
-export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var ConfirmResult;
-( (function(ConfirmResult) {
-    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
-    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
-    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
-})(ConfirmResult || (ConfirmResult = {})));
-
-export { ConfirmResult };

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

@@ -1,371 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, MutableDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { NumberBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
-import { IAuthenticationAccessService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationAccessService';
-import { IAuthenticationUsageService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationUsageService';
-import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-const SCOPESLIST_SEPARATOR = ' ';
-let AuthenticationExtensionsService = class AuthenticationExtensionsService extends Disposable {
-    constructor(activityService, storageService, dialogService, quickInputService, _authenticationService, _authenticationUsageService, _authenticationAccessService) {
-        super();
-        this.activityService = activityService;
-        this.storageService = storageService;
-        this.dialogService = dialogService;
-        this.quickInputService = quickInputService;
-        this._authenticationService = _authenticationService;
-        this._authenticationUsageService = _authenticationUsageService;
-        this._authenticationAccessService = _authenticationAccessService;
-        this._signInRequestItems = ( new Map());
-        this._sessionAccessRequestItems = ( new Map());
-        this._accountBadgeDisposable = this._register(( new MutableDisposable()));
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this._authenticationService.onDidChangeSessions(async (e) => {
-            if (e.event.added?.length) {
-                await this.updateNewSessionRequests(e.providerId, e.event.added);
-            }
-            if (e.event.removed?.length) {
-                await this.updateAccessRequests(e.providerId, e.event.removed);
-            }
-            this.updateBadgeCount();
-        }));
-        this._register(this._authenticationService.onDidUnregisterAuthenticationProvider(e => {
-            const accessRequests = this._sessionAccessRequestItems.get(e.id) || {};
-            ( Object.keys(accessRequests)).forEach(extensionId => {
-                this.removeAccessRequest(e.id, extensionId);
-            });
-        }));
-    }
-    async updateNewSessionRequests(providerId, addedSessions) {
-        const existingRequestsForProvider = this._signInRequestItems.get(providerId);
-        if (!existingRequestsForProvider) {
-            return;
-        }
-        ( Object.keys(existingRequestsForProvider)).forEach(requestedScopes => {
-            if (( addedSessions.some(
-                session => session.scopes.slice().join(SCOPESLIST_SEPARATOR) === requestedScopes
-            ))) {
-                const sessionRequest = existingRequestsForProvider[requestedScopes];
-                sessionRequest?.disposables.forEach(item => item.dispose());
-                delete existingRequestsForProvider[requestedScopes];
-                if (( Object.keys(existingRequestsForProvider)).length === 0) {
-                    this._signInRequestItems.delete(providerId);
-                }
-                else {
-                    this._signInRequestItems.set(providerId, existingRequestsForProvider);
-                }
-            }
-        });
-    }
-    async updateAccessRequests(providerId, removedSessions) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId);
-        if (providerRequests) {
-            ( Object.keys(providerRequests)).forEach(extensionId => {
-                removedSessions.forEach(removed => {
-                    const indexOfSession = providerRequests[extensionId].possibleSessions.findIndex(session => session.id === removed.id);
-                    if (indexOfSession) {
-                        providerRequests[extensionId].possibleSessions.splice(indexOfSession, 1);
-                    }
-                });
-                if (!providerRequests[extensionId].possibleSessions.length) {
-                    this.removeAccessRequest(providerId, extensionId);
-                }
-            });
-        }
-    }
-    updateBadgeCount() {
-        this._accountBadgeDisposable.clear();
-        let numberOfRequests = 0;
-        this._signInRequestItems.forEach(providerRequests => {
-            ( Object.keys(providerRequests)).forEach(request => {
-                numberOfRequests += providerRequests[request].requestingExtensionIds.length;
-            });
-        });
-        this._sessionAccessRequestItems.forEach(accessRequest => {
-            numberOfRequests += ( Object.keys(accessRequest)).length;
-        });
-        if (numberOfRequests > 0) {
-            const badge = ( new NumberBadge(numberOfRequests, () => ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                'sign in',
-                "Sign in requested"
-            ))));
-            this._accountBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
-        }
-    }
-    removeAccessRequest(providerId, extensionId) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
-        if (providerRequests[extensionId]) {
-            dispose(providerRequests[extensionId].disposables);
-            delete providerRequests[extensionId];
-            this.updateBadgeCount();
-        }
-    }
-    updateSessionPreference(providerId, extensionId, session) {
-        const key = `${extensionId}-${providerId}-${session.scopes.join(' ')}`;
-        this.storageService.store(key, session.id, 1 , 1 );
-        this.storageService.store(key, session.id, -1 , 1 );
-    }
-    getSessionPreference(providerId, extensionId, scopes) {
-        const key = `${extensionId}-${providerId}-${scopes.join(' ')}`;
-        return this.storageService.get(key, 1 ) ?? this.storageService.get(key, -1 );
-    }
-    removeSessionPreference(providerId, extensionId, scopes) {
-        const key = `${extensionId}-${providerId}-${scopes.join(' ')}`;
-        this.storageService.remove(key, 1 );
-        this.storageService.remove(key, -1 );
-    }
-    async showGetSessionPrompt(provider, accountName, extensionId, extensionName) {
-        let SessionPromptChoice;
-        ( (function(SessionPromptChoice) {
-            SessionPromptChoice[SessionPromptChoice["Allow"] = 0] = "Allow";
-            SessionPromptChoice[SessionPromptChoice["Deny"] = 1] = "Deny";
-            SessionPromptChoice[SessionPromptChoice["Cancel"] = 2] = "Cancel";
-        })(SessionPromptChoice || (SessionPromptChoice = {})));
-        const { result } = await this.dialogService.prompt({
-            type: Severity.Info,
-            message: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                'confirmAuthenticationAccess',
-                "The extension '{0}' wants to access the {1} account '{2}'.",
-                extensionName,
-                provider.label,
-                accountName
-            )),
-            buttons: [
-                {
-                    label: ( localizeWithPath(
-                        'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                        { key: 'allow', comment: ['&& denotes a mnemonic'] },
-                        "&&Allow"
-                    )),
-                    run: () => SessionPromptChoice.Allow
-                },
-                {
-                    label: ( localizeWithPath(
-                        'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                        { key: 'deny', comment: ['&& denotes a mnemonic'] },
-                        "&&Deny"
-                    )),
-                    run: () => SessionPromptChoice.Deny
-                }
-            ],
-            cancelButton: {
-                run: () => SessionPromptChoice.Cancel
-            }
-        });
-        if (result !== SessionPromptChoice.Cancel) {
-            this._authenticationAccessService.updateAllowedExtensions(provider.id, accountName, [{ id: extensionId, name: extensionName, allowed: result === SessionPromptChoice.Allow }]);
-            this.removeAccessRequest(provider.id, extensionId);
-        }
-        return result === SessionPromptChoice.Allow;
-    }
-    async selectSession(providerId, extensionId, extensionName, scopes, availableSessions) {
-        return ( new Promise((resolve, reject) => {
-            if (!availableSessions.length) {
-                reject('No available sessions');
-                return;
-            }
-            const quickPick = this.quickInputService.createQuickPick();
-            quickPick.ignoreFocusOut = true;
-            const items = ( availableSessions.map(session => {
-                return {
-                    label: session.account.label,
-                    session: session
-                };
-            }));
-            items.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                    'useOtherAccount',
-                    "Sign in to another account"
-                ))
-            });
-            quickPick.items = items;
-            quickPick.title = ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                {
-                    key: 'selectAccount',
-                    comment: ['The placeholder {0} is the name of an extension. {1} is the name of the type of account, such as Microsoft or GitHub.']
-                },
-                "The extension '{0}' wants to access a {1} account",
-                extensionName,
-                this._authenticationService.getProvider(providerId).label
-            ));
-            quickPick.placeholder = ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                'getSessionPlateholder',
-                "Select an account for '{0}' to use or Esc to cancel",
-                extensionName
-            ));
-            quickPick.onDidAccept(async (_) => {
-                const session = quickPick.selectedItems[0].session ?? (await this._authenticationService.createSession(providerId, scopes));
-                const accountName = session.account.label;
-                this._authenticationAccessService.updateAllowedExtensions(providerId, accountName, [{ id: extensionId, name: extensionName, allowed: true }]);
-                this.updateSessionPreference(providerId, extensionId, session);
-                this.removeAccessRequest(providerId, extensionId);
-                quickPick.dispose();
-                resolve(session);
-            });
-            quickPick.onDidHide(_ => {
-                if (!quickPick.selectedItems[0]) {
-                    reject('User did not consent to account access');
-                }
-                quickPick.dispose();
-            });
-            quickPick.show();
-        }));
-    }
-    async completeSessionAccessRequest(provider, extensionId, extensionName, scopes) {
-        const providerRequests = this._sessionAccessRequestItems.get(provider.id) || {};
-        const existingRequest = providerRequests[extensionId];
-        if (!existingRequest) {
-            return;
-        }
-        if (!provider) {
-            return;
-        }
-        const possibleSessions = existingRequest.possibleSessions;
-        let session;
-        if (provider.supportsMultipleAccounts) {
-            try {
-                session = await this.selectSession(provider.id, extensionId, extensionName, scopes, possibleSessions);
-            }
-            catch (_) {
-            }
-        }
-        else {
-            const approved = await this.showGetSessionPrompt(provider, possibleSessions[0].account.label, extensionId, extensionName);
-            if (approved) {
-                session = possibleSessions[0];
-            }
-        }
-        if (session) {
-            this._authenticationUsageService.addAccountUsage(provider.id, session.account.label, extensionId, extensionName);
-        }
-    }
-    requestSessionAccess(providerId, extensionId, extensionName, scopes, possibleSessions) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
-        const hasExistingRequest = providerRequests[extensionId];
-        if (hasExistingRequest) {
-            return;
-        }
-        const provider = this._authenticationService.getProvider(providerId);
-        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '3_accessRequests',
-            command: {
-                id: `${providerId}${extensionId}Access`,
-                title: ( localizeWithPath(
-                    'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                    {
-                        key: 'accessRequest',
-                        comment: [`The placeholder {0} will be replaced with an authentication provider''s label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count`]
-                    },
-                    "Grant access to {0} for {1}... (1)",
-                    provider.label,
-                    extensionName
-                ))
-            }
-        }));
-        const accessCommand = CommandsRegistry.registerCommand({
-            id: `${providerId}${extensionId}Access`,
-            handler: async (accessor) => {
-                this.completeSessionAccessRequest(provider, extensionId, extensionName, scopes);
-            }
-        });
-        providerRequests[extensionId] = { possibleSessions, disposables: [menuItem, accessCommand] };
-        this._sessionAccessRequestItems.set(providerId, providerRequests);
-        this.updateBadgeCount();
-    }
-    async requestNewSession(providerId, scopes, extensionId, extensionName) {
-        if (!this._authenticationService.isAuthenticationProviderRegistered(providerId)) {
-            await ( new Promise((resolve, _) => {
-                const dispose = this._authenticationService.onDidRegisterAuthenticationProvider(e => {
-                    if (e.id === providerId) {
-                        dispose.dispose();
-                        resolve();
-                    }
-                });
-            }));
-        }
-        let provider;
-        try {
-            provider = this._authenticationService.getProvider(providerId);
-        }
-        catch (_e) {
-            return;
-        }
-        const providerRequests = this._signInRequestItems.get(providerId);
-        const scopesList = scopes.join(SCOPESLIST_SEPARATOR);
-        const extensionHasExistingRequest = providerRequests
-            && providerRequests[scopesList]
-            && providerRequests[scopesList].requestingExtensionIds.includes(extensionId);
-        if (extensionHasExistingRequest) {
-            return;
-        }
-        const commandId = `${providerId}:${extensionId}:signIn${( Object.keys(providerRequests || [])).length}`;
-        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '2_signInRequests',
-            command: {
-                id: commandId,
-                title: ( localizeWithPath(
-                    'vs/workbench/services/authentication/browser/authenticationExtensionsService',
-                    {
-                        key: 'signInRequest',
-                        comment: [`The placeholder {0} will be replaced with an authentication provider's label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count.`]
-                    },
-                    "Sign in with {0} to use {1} (1)",
-                    provider.label,
-                    extensionName
-                ))
-            }
-        }));
-        const signInCommand = CommandsRegistry.registerCommand({
-            id: commandId,
-            handler: async (accessor) => {
-                const authenticationService = accessor.get(IAuthenticationService);
-                const session = await authenticationService.createSession(providerId, scopes);
-                this._authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: true }]);
-                this.updateSessionPreference(providerId, extensionId, session);
-            }
-        });
-        if (providerRequests) {
-            const existingRequest = providerRequests[scopesList] || { disposables: [], requestingExtensionIds: [] };
-            providerRequests[scopesList] = {
-                disposables: [...existingRequest.disposables, menuItem, signInCommand],
-                requestingExtensionIds: [...existingRequest.requestingExtensionIds, extensionId]
-            };
-            this._signInRequestItems.set(providerId, providerRequests);
-        }
-        else {
-            this._signInRequestItems.set(providerId, {
-                [scopesList]: {
-                    disposables: [menuItem, signInCommand],
-                    requestingExtensionIds: [extensionId]
-                }
-            });
-        }
-        this.updateBadgeCount();
-    }
-};
-AuthenticationExtensionsService = ( __decorate([
-    ( __param(0, IActivityService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IAuthenticationService)),
-    ( __param(5, IAuthenticationUsageService)),
-    ( __param(6, IAuthenticationAccessService))
-], AuthenticationExtensionsService));
-
-export { AuthenticationExtensionsService };