@theia/core 1.19.0 → 1.20.0

package/src/browser/messaging/ws-connection-provider.ts

@@ -59,13 +59,19 @@ export const DEFAULT_HTTP_FALLBACK_OPTIONS: HttpFallbackOptions = {
 export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebSocketOptions> {
 
     protected readonly onSocketDidOpenEmitter: Emitter<void> = new Emitter();
-    readonly onSocketDidOpen: Event<void> = this.onSocketDidOpenEmitter.event;
+    get onSocketDidOpen(): Event<void> {
+        return this.onSocketDidOpenEmitter.event;
+    }
 
     protected readonly onSocketDidCloseEmitter: Emitter<void> = new Emitter();
-    readonly onSocketDidClose: Event<void> = this.onSocketDidCloseEmitter.event;
+    get onSocketDidClose(): Event<void> {
+        return this.onSocketDidCloseEmitter.event;
+    }
 
     protected readonly onHttpFallbackDidActivateEmitter: Emitter<void> = new Emitter();
-    readonly onHttpFallbackDidActivate: Event<void> = this.onHttpFallbackDidActivateEmitter.event;
+    get onHttpFallbackDidActivate(): Event<void> {
+        return this.onHttpFallbackDidActivateEmitter.event;
+    }
 
     static createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): JsonRpcProxy<T> {
         return container.get(WebSocketConnectionProvider).createProxy<T>(path, arg);
@@ -98,7 +104,6 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
             this.fireSocketDidClose();
         };
         socket.onmessage = ({ data }) => {
-            this.websocketErrorCounter = 0;
             this.handleIncomingRawMessage(data);
         };
         this.socket = socket;
@@ -218,6 +223,10 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
     }
 
     protected fireSocketDidOpen(): void {
+        // Once a websocket connection has opened, disable the http fallback
+        if (this.httpFallbackOptions?.allowed) {
+            this.httpFallbackOptions.allowed = false;
+        }
         this.onSocketDidOpenEmitter.fire(undefined);
     }
 

package/src/browser/quick-input/quick-command-frontend-contribution.ts

@@ -43,7 +43,7 @@ export class QuickCommandFrontendContribution implements CommandContribution, Ke
     registerMenus(menus: MenuModelRegistry): void {
         menus.registerMenuAction(CommonMenus.VIEW_PRIMARY, {
             commandId: quickCommand.id,
-            label: nls.localize('vscode/quickAccess.contribution/commandsQuickAccess', 'Find Command...')
+            label: nls.localizeByDefault('Command Palette...')
         });
     }
 

package/src/browser/quick-input/quick-command-service.ts

@@ -28,10 +28,10 @@ export const quickCommand: Command = {
     id: 'workbench.action.showCommands'
 };
 
-export const CLEAR_COMMAND_HISTORY = Command.toLocalizedCommand({
+export const CLEAR_COMMAND_HISTORY = Command.toDefaultLocalizedCommand({
     id: 'clear.command.history',
     label: 'Clear Command History'
-}, 'vscode/commandsQuickAccess/clearCommandHistory');
+});
 
 @injectable()
 export class QuickCommandService implements QuickAccessContribution, QuickAccessProvider {

package/src/browser/quick-input/quick-input-service.ts

@@ -14,281 +14,4 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { CancellationToken, Event } from '../../common';
-import URI from '../../common/uri';
-import { KeySequence } from '../keyboard';
-import * as fuzzy from 'fuzzy';
-
-export interface Match {
-    start: number;
-    end: number;
-}
-export interface QuickPickItemHighlights {
-    label?: Match[];
-    description?: Match[];
-    detail?: Match[];
-}
-
-export interface QuickPickItem {
-    type?: 'item' | 'separator';
-    id?: string;
-    label: string;
-    meta?: string;
-    ariaLabel?: string;
-    description?: string;
-    detail?: string;
-    keySequence?: KeySequence;
-    iconClasses?: string[];
-    alwaysShow?: boolean;
-    highlights?: QuickPickItemHighlights;
-    buttons?: QuickInputButton[];
-    execute?: () => void;
-}
-
-export namespace QuickPickItem {
-    export function is(item: QuickPickSeparator | QuickPickItem): item is QuickPickItem {
-        // if it's not a separator, it's an item
-        return item.type !== 'separator';
-    }
-}
-
-export interface QuickPickSeparator {
-    type: 'separator';
-    label?: string;
-}
-
-export namespace QuickPickSeparator {
-    export function is(item: QuickPickSeparator | QuickPickItem): item is QuickPickSeparator {
-        return item.type === 'separator';
-    }
-}
-
-export type QuickPicks = (QuickPickSeparator | QuickPickItem)[];
-
-export interface QuickPickValue<V> extends QuickPickItem {
-    value: V
-}
-
-export interface QuickInputButton {
-    iconPath?: URI | { light: URI; dark: URI } | { id: string };
-    iconClass?: string;
-    tooltip?: string;
-}
-
-export interface QuickInputButtonHandle extends QuickInputButton {
-    index: number; // index of where they are in buttons array if QuickInputButton or -1 if QuickInputButtons.Back
-}
-
-export interface QuickInput {
-    readonly onDidHide: Event<void>;
-    readonly onDispose: Event<void>;
-    title: string | undefined;
-    description: string | undefined;
-    step: number | undefined;
-    totalSteps: number | undefined;
-    enabled: boolean;
-    contextKey: string | undefined;
-    busy: boolean;
-    ignoreFocusOut: boolean;
-    show(): void;
-    hide(): void;
-    dispose(): void;
-}
-
-export interface InputBox extends QuickInput {
-    value: string | undefined;
-    valueSelection: Readonly<[number, number]> | undefined;
-    placeholder: string | undefined;
-    password: boolean;
-    readonly onDidChangeValue: Event<string>;
-    readonly onDidAccept: Event<void>;
-    buttons: ReadonlyArray<QuickInputButton>;
-    readonly onDidTriggerButton: Event<QuickInputButton>;
-    prompt: string | undefined;
-    validationMessage: string | undefined;
-}
-
-export interface QuickPick<T extends QuickPickItem> extends QuickInput {
-    value: string;
-    placeholder: string | undefined;
-    items: ReadonlyArray<T | QuickPickSeparator>;
-    activeItems: ReadonlyArray<T>;
-    selectedItems: ReadonlyArray<T>;
-    canSelectMany: boolean;
-    matchOnDescription: boolean;
-    matchOnDetail: boolean;
-    readonly onDidAccept: Event<void>;
-    readonly onDidChangeValue: Event<string>;
-    readonly onDidTriggerButton: Event<QuickInputButton>;
-    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<T>>;
-    readonly onDidChangeActive: Event<T[]>;
-    readonly onDidChangeSelection: Event<T[]>;
-}
-
-export interface PickOptions<T extends QuickPickItem> {
-    placeHolder?: string;
-    matchOnDescription?: boolean;
-    matchOnDetail?: boolean;
-    matchOnLabel?: boolean;
-    autoFocusOnList?: boolean;
-    ignoreFocusLost?: boolean;
-    canPickMany?: boolean;
-    contextKey?: string;
-    activeItem?: Promise<T> | T;
-    onDidFocus?: (entry: T) => void;
-}
-
-export interface InputOptions {
-    value?: string;
-    valueSelection?: [number, number];
-    prompt?: string;
-    placeHolder?: string;
-    password?: boolean;
-    ignoreFocusLost?: boolean;
-    validateInput?(input: string): Promise<string | null | undefined> | undefined;
-}
-
-export interface QuickPickItemButtonEvent<T extends QuickPickItem> {
-    button: QuickInputButton;
-    item: T;
-}
-
-export interface QuickPickOptions<T extends QuickPickItem> {
-    busy?: boolean;
-    enabled?: boolean;
-    title?: string;
-    description?: string;
-    value?: string;
-    filterValue?: (value: string) => string;
-    ariaLabel?: string;
-    buttons?: Array<QuickInputButton>;
-    placeholder?: string;
-    canAcceptInBackground?: boolean;
-    customButton?: boolean;
-    customLabel?: string;
-    customHover?: string;
-    canSelectMany?: boolean;
-    matchOnDescription?: boolean;
-    matchOnDetail?: boolean;
-    matchOnLabel?: boolean;
-    sortByLabel?: boolean;
-    autoFocusOnList?: boolean;
-    ignoreFocusOut?: boolean;
-    valueSelection?: Readonly<[number, number]>;
-    validationMessage?: string;
-    hideInput?: boolean;
-    hideCheckAll?: boolean;
-    runIfSingle?: boolean
-    contextKey?: string;
-    activeItem?: T,
-    step?: number;
-    totalSteps?: number;
-
-    onDidAccept?: () => void,
-    onDidChangeActive?: (quickPick: QuickPick<T>, activeItems: Array<T>) => void,
-    onDidChangeSelection?: (quickPick: QuickPick<T>, selectedItems: Array<T>) => void,
-    onDidChangeValue?: (quickPick: QuickPick<T>, filter: string) => void,
-    onDidCustom?: () => void,
-    onDidHide?: () => void;
-    onDidTriggerButton?: (button: QuickInputButton) => void,
-    onDidTriggerItemButton?: (ItemButtonEvent: QuickPickItemButtonEvent<T>) => void
-}
-
-export const QuickInputService = Symbol('QuickInputService');
-export interface QuickInputService {
-    readonly backButton: QuickInputButton;
-    readonly onShow: Event<void>;
-    readonly onHide: Event<void>;
-    open(filter: string): void;
-    createInputBox(): InputBox;
-    input(options?: InputOptions, token?: CancellationToken): Promise<string | undefined>;
-    pick<T extends QuickPickItem, O extends PickOptions<T>>(picks: Promise<T[]> | T[], options?: O, token?: CancellationToken):
-        Promise<(O extends { canPickMany: true } ? T[] : T) | undefined>;
-    showQuickPick<T extends QuickPickItem>(items: Array<T>, options?: QuickPickOptions<T>): Promise<T>;
-    hide(): void;
-    /**
-     * Provides raw access to the quick pick controller.
-     */
-    createQuickPick<T extends QuickPickItem>(): QuickPick<T>;
-}
-
-/**
- * Filter the list of quick pick items based on the provided filter.
- * Items are filtered based on if:
- * - their `label` satisfies the filter using `fuzzy`.
- * - their `description` satisfies the filter using `fuzzy`.
- * - their `detail` satisfies the filter using `fuzzy`.
- * Filtered items are also updated to display proper highlights based on how they were filtered.
- * @param items the list of quick pick items.
- * @param filter the filter to search for.
- * @returns the list of quick pick items that satisfy the filter.
- */
-export function filterItems(items: QuickPickItem[], filter: string): QuickPickItem[] {
-    filter = filter.trim().toLowerCase();
-
-    if (filter.length === 0) {
-        for (const item of items) {
-            item.highlights = undefined; // reset highlights from previous filtering.
-        }
-        return items;
-    }
-
-    const filteredItems: QuickPickItem[] = [];
-    for (const item of items) {
-        if (
-            fuzzy.test(filter, item.label) ||
-            (item.description && fuzzy.test(filter, item.description)) ||
-            (item.detail && fuzzy.test(filter, item.detail))
-        ) {
-            item.highlights = {
-                label: findMatches(item.label, filter),
-                description: item.description ? findMatches(item.description, filter) : undefined,
-                detail: item.detail ? findMatches(item.detail, filter) : undefined
-            };
-            filteredItems.push(item);
-        }
-    }
-    return filteredItems;
-}
-
-/**
- * Find match highlights when testing a word against a pattern.
- * @param word the word to test.
- * @param pattern the word to match against.
- * @returns the list of highlights if present.
- */
-export function findMatches(word: string, pattern: string): Array<{ start: number, end: number }> | undefined {
-    word = word.toLocaleLowerCase();
-    pattern = pattern.toLocaleLowerCase();
-
-    if (pattern.trim().length === 0) {
-        return undefined;
-    }
-
-    const delimiter = '\u0000'; // null byte that shouldn't appear in the input and is used to denote matches.
-    const matchResult = fuzzy.match(pattern.replace(/\u0000/gu, ''), word, { pre: delimiter, post: delimiter });
-    if (!matchResult) {
-        return undefined;
-    }
-
-    const match = matchResult.rendered;
-    const highlights: { start: number, end: number }[] = [];
-
-    let lastIndex = 0;
-    /** We need to account for the extra markers by removing them from the range */
-    let offset = 0;
-
-    while (true) {
-        const start = match.indexOf(delimiter, lastIndex);
-        if (start === -1) { break; }
-        const end = match.indexOf(delimiter, start + 1);
-        if (end === -1) { break; }
-        highlights.push({
-            start: start - offset++,
-            end: end - offset++
-        });
-        lastIndex = end + 1;
-    }
-
-    return highlights.length > 0 ? highlights : undefined;
-}
+export * from '../../common/quick-pick-service';

package/src/browser/shell/tab-bar-toolbar.tsx

@@ -405,7 +405,7 @@ export class TabBarToolbar extends ReactWidget {
     protected renderMore(): React.ReactNode {
         return !!this.more.size && <div key='__more__' className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled'}>
             <div id='__more__' className={codicon('ellipsis', true)} onClick={this.showMoreContextMenu}
-                title={nls.localize('vscode/compositePart/viewsAndMoreActions', 'More Actions...')} />
+                title={nls.localizeByDefault('More Actions...')} />
         </div>;
     }
 

package/src/browser/storage-service.spec.ts

@@ -34,7 +34,7 @@ before(() => {
         MockLogger since it does what we need but this is there as a demo of
         sinon for other uses-cases. We can remove this once this technique is
         more generally used. */
-        sinon.stub(logger, 'warn').callsFake(() => { });
+        sinon.stub(logger, 'warn').callsFake(async () => { });
         return logger;
     });
     testContainer.bind(StorageService).to(LocalStorageService).inSingletonScope();

package/src/browser/theming.ts

@@ -18,25 +18,14 @@ import { Emitter, Event } from '../common/event';
 import { Disposable } from '../common/disposable';
 import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import { ApplicationProps } from '@theia/application-package/lib/application-props';
+import { Theme, ThemeChangeEvent } from '../common/theme';
 
-export const ThemeServiceSymbol = Symbol('ThemeService');
-
-export type ThemeType = 'light' | 'dark' | 'hc';
-
-export interface Theme {
-    readonly id: string;
-    readonly type: ThemeType;
-    readonly label: string;
-    readonly description?: string;
-    readonly editorTheme?: string;
-    activate(): void;
-    deactivate(): void;
-}
+/**
+ * @deprecated since 1.20.0. Import from `@theia/core/lib/common/theme` instead.
+ */
+export * from '../common/theme';
 
-export interface ThemeChangeEvent {
-    readonly newTheme: Theme;
-    readonly oldTheme?: Theme;
-}
+export const ThemeServiceSymbol = Symbol('ThemeService');
 
 export class ThemeService {
 

package/src/browser/window/default-window-service.ts

@@ -50,7 +50,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
     }
 
     openNewDefaultWindow(): void {
-        this.openNewWindow(DEFAULT_WINDOW_HASH);
+        this.openNewWindow(`#${DEFAULT_WINDOW_HASH}`);
     }
 
     canUnload(): boolean {

package/src/browser/window-contribution.ts

@@ -23,10 +23,10 @@ import { CommonMenus } from '../browser/common-frontend-contribution';
 
 export namespace WindowCommands {
 
-    export const NEW_WINDOW = Command.toLocalizedCommand({
+    export const NEW_WINDOW = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.newWindow',
         label: 'New Window'
-    }, 'vscode/windowActions/newWindow');
+    });
 }
 
 @injectable()

package/src/common/color.ts

@@ -0,0 +1,100 @@
+/********************************************************************************
+ * Copyright (C) 2019 TypeFox and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+/**
+ * Either be a reference to an existing color or a color value as a hex string, rgba, or hsla.
+ */
+export type Color = string | RGBA | HSLA | ColorTransformation;
+export namespace Color {
+    export function rgba(r: number, g: number, b: number, a: number = 1): Color {
+        return { r, g, b, a };
+    }
+    export function hsla(h: number, s: number, l: number, a: number = 1): Color {
+        return { h, s, l, a };
+    }
+    export const white = rgba(255, 255, 255, 1);
+    export const black = rgba(0, 0, 0, 1);
+    export function transparent(v: string, f: number): ColorTransformation {
+        return { v, f, kind: 'transparent' };
+    }
+    export function lighten(v: string, f: number): ColorTransformation {
+        return { v, f, kind: 'lighten' };
+    }
+    export function darken(v: string, f: number): ColorTransformation {
+        return { v, f, kind: 'darken' };
+    }
+}
+export interface ColorTransformation {
+    kind: 'transparent' | 'lighten' | 'darken'
+    v: string
+    f: number
+}
+export interface RGBA {
+    /**
+     * Red: integer in [0-255]
+     */
+    readonly r: number;
+
+    /**
+     * Green: integer in [0-255]
+     */
+    readonly g: number;
+
+    /**
+     * Blue: integer in [0-255]
+     */
+    readonly b: number;
+
+    /**
+     * Alpha: float in [0-1]
+     */
+    readonly a: number;
+}
+export interface HSLA {
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Luminosity: float in [0, 1]
+     */
+    readonly l: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+}
+
+export interface ColorDefaults {
+    light?: Color
+    dark?: Color
+    hc?: Color
+}
+
+export interface ColorDefinition {
+    id: string
+    defaults?: ColorDefaults
+    description: string
+}
+
+export interface ColorCssVariable {
+    name: string
+    value: string
+}

package/src/common/command.ts

@@ -64,6 +64,16 @@ export namespace Command {
         };
     }
 
+    export function toDefaultLocalizedCommand(command: Command): Command {
+        return {
+            ...command,
+            label: command.label && nls.localizeByDefault(command.label),
+            originalLabel: command.label,
+            category: command.category && nls.localizeByDefault(command.category),
+            originalCategory: command.category,
+        };
+    }
+
     /** Comparator function for when sorting commands */
     export function compareCommands(a: Command, b: Command): number {
         if (a.label && b.label) {

package/src/common/i18n/localization.ts

@@ -36,7 +36,7 @@ export type FormatType = string | number | boolean | undefined;
 
 export namespace Localization {
 
-    function format(message: string, args: FormatType[]): string {
+    export function format(message: string, args: FormatType[]): string {
         let result = message;
         if (args.length > 0) {
             result = message.replace(/\{(\d+)\}/g, (match, rest) => {
@@ -59,13 +59,23 @@ export namespace Localization {
         if (localization) {
             const translation = localization.translations[key];
             if (translation) {
-                // vscode's localizations often contain additional '&&' symbols, which we simply ignore
-                value = translation.replace(/&&/g, '');
+                value = normalize(translation);
             }
         }
         return format(value, args);
     }
 
+    /**
+     * This function normalizes values from VSCode's localizations, which often contain additional mnemonics (`&&`).
+     * The normalization removes the mnemonics from the input string.
+     *
+     * @param value Localization value coming from VSCode
+     * @returns A normalized localized value
+     */
+    export function normalize(value: string): string {
+        return value.replace(/&&/g, '');
+    }
+
     export function transformKey(key: string): string {
         let nlsKey = key;
         const keySlashIndex = key.lastIndexOf('/');