@theia/core 1.53.2 → 1.54.0

package/src/browser/authentication-service.ts

@@ -32,6 +32,13 @@ export interface AuthenticationSessionAccountInformation {
     readonly id: string;
     readonly label: string;
 }
+export interface AuthenticationProviderSessionOptions {
+    /**
+     * The account that is being asked about. If this is passed in, the provider should
+     * attempt to return the sessions that are only related to this account.
+     */
+    account?: AuthenticationSessionAccountInformation;
+}
 
 export interface AuthenticationSession {
     id: string;
@@ -82,16 +89,6 @@ export interface AuthenticationProvider {
 
     updateSessionItems(event: AuthenticationProviderAuthenticationSessionsChangeEvent): Promise<void>;
 
-    /**
-     * @deprecated use `createSession` instead.
-     */
-    login(scopes: string[]): Promise<AuthenticationSession>;
-
-    /**
-     * @deprecated use `removeSession` instead.
-     */
-    logout(sessionId: string): Promise<void>;
-
     /**
      * An [event](#Event) which fires when the array of sessions has changed, or data
      * within a session has changed.
@@ -102,16 +99,18 @@ export interface AuthenticationProvider {
      * Get a list of sessions.
      * @param scopes An optional list of scopes. If provided, the sessions returned should match
      * these permissions, otherwise all sessions should be returned.
+     * @param account The optional account that you would like to get the session for
      * @returns A promise that resolves to an array of authentication sessions.
      */
-    getSessions(scopes?: string[]): Thenable<ReadonlyArray<AuthenticationSession>>;
+    getSessions(scopes: string[] | undefined, account?: AuthenticationSessionAccountInformation): Thenable<ReadonlyArray<AuthenticationSession>>;
 
     /**
      * Prompts a user to login.
      * @param scopes A list of scopes, permissions, that the new session should be created with.
+     * @param options The options for createing the session
      * @returns A promise that resolves to an authentication session.
      */
-    createSession(scopes: string[]): Thenable<AuthenticationSession>;
+    createSession(scopes: string[], options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession>;
 
     /**
      * Removes the session corresponding to session id.
@@ -134,10 +133,10 @@ export interface AuthenticationService {
 
     readonly onDidChangeSessions: Event<{ providerId: string, label: string, event: AuthenticationProviderAuthenticationSessionsChangeEvent }>;
     readonly onDidUpdateSignInCount: Event<number>;
-    getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>>;
+    getSessions(providerId: string, scopes?: string[], user?: AuthenticationSessionAccountInformation): Promise<ReadonlyArray<AuthenticationSession>>;
     getLabel(providerId: string): string;
     supportsMultipleAccounts(providerId: string): boolean;
-    login(providerId: string, scopes: string[]): Promise<AuthenticationSession>;
+    login(providerId: string, scopes: string[], options?: AuthenticationProviderSessionOptions): Promise<AuthenticationSession>;
     logout(providerId: string, sessionId: string): Promise<void>;
 
     signOutOfAccount(providerId: string, accountName: string): Promise<void>;
@@ -300,7 +299,7 @@ export class AuthenticationServiceImpl implements AuthenticationService {
         }
 
         const previousSize = this.signInRequestItems.size;
-        const sessions = await provider.getSessions();
+        const sessions = await provider.getSessions(undefined);
         Object.keys(existingRequestsForProvider).forEach(requestedScopes => {
             if (sessions.some(session => session.scopes.slice().sort().join('') === requestedScopes)) {
                 const sessionRequest = existingRequestsForProvider[requestedScopes];
@@ -411,19 +410,19 @@ export class AuthenticationServiceImpl implements AuthenticationService {
         }
     }
 
-    async getSessions(id: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>> {
+    async getSessions(id: string, scopes?: string[], user?: AuthenticationSessionAccountInformation): Promise<ReadonlyArray<AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(id);
         if (authProvider) {
-            return authProvider.getSessions(scopes);
+            return authProvider.getSessions(scopes, user);
         } else {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
     }
 
-    async login(id: string, scopes: string[]): Promise<AuthenticationSession> {
+    async login(id: string, scopes: string[], options?: AuthenticationProviderSessionOptions): Promise<AuthenticationSession> {
         const authProvider = this.authenticationProviders.get(id);
         if (authProvider) {
-            return authProvider.createSession(scopes);
+            return authProvider.createSession(scopes, options || {});
         } else {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }

package/src/browser/core-preferences.ts

@@ -281,6 +281,15 @@ export const corePreferenceSchema: PreferenceSchema = {
             default: 200,
             minimum: 10,
             description: nls.localize('theia/core/tabDefaultSize', 'Specifies the default size for tabs.')
+        },
+        'workbench.editorAssociations': {
+            type: 'object',
+            markdownDescription: nls.localizeByDefault('Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `"*.hex": "hexEditor.hexedit"`). These have precedence over the default behavior.'),
+            patternProperties: {
+                '.*': {
+                    type: 'string'
+                }
+            }
         }
     }
 };

package/src/browser/open-with-service.ts

@@ -19,7 +19,9 @@ import { Disposable } from '../common/disposable';
 import { nls } from '../common/nls';
 import { MaybePromise } from '../common/types';
 import { URI } from '../common/uri';
-import { QuickInputService } from './quick-input';
+import { QuickInputService, QuickPickItem, QuickPickItemOrSeparator } from './quick-input';
+import { PreferenceScope, PreferenceService } from './preferences';
+import { getDefaultHandler } from './opener-service';
 
 export interface OpenWithHandler {
     /**
@@ -46,6 +48,11 @@ export interface OpenWithHandler {
      * A returned value indicating a priority of this handler.
      */
     canHandle(uri: URI): number;
+    /**
+     * Test whether this handler and open the given URI
+     * and return the order of this handler in the list.
+     */
+    getOrder?(uri: URI): number;
     /**
      * Open a widget for the given URI and options.
      * Resolve to an opened widget or undefined, e.g. if a page is opened.
@@ -54,12 +61,19 @@ export interface OpenWithHandler {
     open(uri: URI): MaybePromise<object | undefined>;
 }
 
+export interface OpenWithQuickPickItem extends QuickPickItem {
+    handler: OpenWithHandler;
+}
+
 @injectable()
 export class OpenWithService {
 
     @inject(QuickInputService)
     protected readonly quickInputService: QuickInputService;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     protected readonly handlers: OpenWithHandler[] = [];
 
     registerHandler(handler: OpenWithHandler): Disposable {
@@ -73,17 +87,50 @@ export class OpenWithService {
     }
 
     async openWith(uri: URI): Promise<object | undefined> {
+        // Clone the object, because all objects returned by the preferences service are frozen.
+        const associations: Record<string, unknown> = { ...this.preferenceService.get('workbench.editorAssociations') };
+        const ext = `*${uri.path.ext}`;
         const handlers = this.getHandlers(uri);
-        const result = await this.quickInputService.pick(handlers.map(handler => ({
-            handler: handler,
-            label: handler.label ?? handler.id,
-            detail: handler.providerName
-        })), {
+        const ordered = handlers.slice().sort((a, b) => this.getOrder(b, uri) - this.getOrder(a, uri));
+        const defaultHandler = getDefaultHandler(uri, this.preferenceService) ?? handlers[0]?.id;
+        const items = this.getQuickPickItems(ordered, defaultHandler);
+        // Only offer to select a default editor when the file has a file extension
+        const extraItems: QuickPickItemOrSeparator[] = uri.path.ext ? [{
+            type: 'separator'
+        }, {
+            label: nls.localizeByDefault("Configure default editor for '{0}'...", ext)
+        }] : [];
+        const result = await this.quickInputService.pick<OpenWithQuickPickItem | { label: string }>([...items, ...extraItems], {
             placeHolder: nls.localizeByDefault("Select editor for '{0}'", uri.path.base)
         });
         if (result) {
-            return result.handler.open(uri);
+            if ('handler' in result) {
+                return result.handler.open(uri);
+            } else if (result.label) {
+                const configureResult = await this.quickInputService.pick(items, {
+                    placeHolder: nls.localizeByDefault("Select new default editor for '{0}'", ext)
+                });
+                if (configureResult) {
+                    associations[ext] = configureResult.handler.id;
+                    this.preferenceService.set('workbench.editorAssociations', associations, PreferenceScope.User);
+                    return configureResult.handler.open(uri);
+                }
+            }
         }
+        return undefined;
+    }
+
+    protected getQuickPickItems(handlers: OpenWithHandler[], defaultHandler?: string): OpenWithQuickPickItem[] {
+        return handlers.map(handler => ({
+            handler,
+            label: handler.label ?? handler.id,
+            detail: handler.providerName ?? '',
+            description: handler.id === defaultHandler ? nls.localizeByDefault('Default') : undefined
+        }));
+    }
+
+    protected getOrder(handler: OpenWithHandler, uri: URI): number {
+        return handler.getOrder ? handler.getOrder(uri) : handler.canHandle(uri);
     }
 
     getHandlers(uri: URI): OpenWithHandler[] {

package/src/browser/opener-service.ts

@@ -17,6 +17,8 @@
 import { named, injectable, inject } from 'inversify';
 import URI from '../common/uri';
 import { ContributionProvider, Prioritizeable, MaybePromise, Emitter, Event, Disposable } from '../common';
+import { PreferenceService } from './preferences';
+import { match } from '../common/glob';
 
 export interface OpenerOptions {
 }
@@ -96,6 +98,17 @@ export async function open(openerService: OpenerService, uri: URI, options?: Ope
     return opener.open(uri, options);
 }
 
+export function getDefaultHandler(uri: URI, preferenceService: PreferenceService): string | undefined {
+    const associations = preferenceService.get('workbench.editorAssociations', {});
+    const defaultHandler = Object.entries(associations).find(([key]) => match(key, uri.path.base))?.[1];
+    if (typeof defaultHandler === 'string') {
+        return defaultHandler;
+    }
+    return undefined;
+}
+
+export const defaultHandlerPriority = 100_000;
+
 @injectable()
 export class DefaultOpenerService implements OpenerService {
     // Collection of open-handlers for custom-editor contributions.

package/src/browser/widgets/extractable-widget.ts

@@ -28,6 +28,6 @@ export interface ExtractableWidget extends Widget {
 
 export namespace ExtractableWidget {
     export function is(widget: unknown): widget is ExtractableWidget {
-        return widget instanceof Widget && widget.hasOwnProperty('isExtractable') && (widget as ExtractableWidget).isExtractable === true;
+        return widget instanceof Widget && 'isExtractable' in widget && (widget as ExtractableWidget).isExtractable === true;
     }
 }

package/src/common/glob.ts

@@ -454,10 +454,10 @@ function toRegExp(pattern: string): ParsedStringPattern {
 
 /**
  * Simplified glob matching. Supports a subset of glob patterns:
- * - * matches anything inside a path segment
- * - ? matches 1 character inside a path segment
- * - ** matches anything including an empty path segment
- * - simple brace expansion ({js,ts} => js or ts)
+ * - `*` matches anything inside a path segment
+ * - `?` matches 1 character inside a path segment
+ * - `**` matches anything including an empty path segment
+ * - simple brace expansion (`{js,ts}` => js or ts)
  * - character ranges (using [...])
  */
 export function match(pattern: string | IRelativePattern, path: string): boolean;