@theia/core 1.19.0 → 1.20.0

package/src/common/messaging/abstract-connection-provider.ts

@@ -49,7 +49,9 @@ export abstract class AbstractConnectionProvider<AbstractOptions extends object>
     protected readonly channels = new Map<number, WebSocketChannel>();
 
     protected readonly onIncomingMessageActivityEmitter: Emitter<void> = new Emitter();
-    public onIncomingMessageActivity: Event<void> = this.onIncomingMessageActivityEmitter.event;
+    get onIncomingMessageActivity(): Event<void> {
+        return this.onIncomingMessageActivityEmitter.event;
+    }
 
     /**
      * Create a proxy object to remote interface of T type

package/src/common/messaging/proxy-factory.ts

@@ -240,7 +240,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
                     try {
                         if (isNotify) {
                             connection.sendNotification(method, ...args);
-                            resolve();
+                            resolve(undefined);
                         } else {
                             const resultPromise = connection.sendRequest(method, ...args) as Promise<any>;
                             resultPromise

package/src/common/nls.ts

@@ -24,7 +24,81 @@ export namespace nls {
 
     export const locale = typeof window === 'object' && window && window.localStorage.getItem(localeId) || undefined;
 
+    let keyProvider: LocalizationKeyProvider | undefined;
+
+    /**
+     * Automatically localizes a text if that text also exists in the vscode repository.
+     */
+    export function localizeByDefault(defaultValue: string, ...args: FormatType[]): string {
+        const key = getDefaultKey(defaultValue);
+        if (key) {
+            return localize(key, defaultValue, ...args);
+        }
+        return Localization.format(defaultValue, args);
+    }
+
+    export function getDefaultKey(defaultValue: string): string {
+        if (localization) {
+            if (!keyProvider) {
+                keyProvider = new LocalizationKeyProvider();
+            }
+            const key = keyProvider.get(defaultValue);
+            if (key) {
+                return key;
+            } else {
+                console.warn(`Could not find translation key for default value: "${defaultValue}"`);
+            }
+        }
+        return '';
+    }
+
     export function localize(key: string, defaultValue: string, ...args: FormatType[]): string {
         return Localization.localize(localization, key, defaultValue, ...args);
     }
 }
+
+interface NlsKeys {
+    [key: string]: (string | NlsInfo)[]
+}
+
+interface NlsInfo {
+    key: string
+    comment: string[]
+}
+
+class LocalizationKeyProvider {
+
+    private data = this.buildData();
+
+    get(defaultValue: string): string | undefined {
+        return this.data.get(defaultValue);
+    }
+
+    /**
+     * Transforms the data coming from the `nls.metadata.json` file into a map.
+     * The original data contains arrays of keys and messages.
+     * The result is a map that matches each message to the key that belongs to it.
+     *
+     * This allows us to skip the key in the localization process and map the original english default values to their translations in different languages.
+     */
+    private buildData(): Map<string, string> {
+        const bundles = require('../../src/common/i18n/nls.metadata.json');
+        const keys: NlsKeys = bundles.keys;
+        const messages: Record<string, string[]> = bundles.messages;
+        const data = new Map<string, string>();
+        for (const [fileKey, messageBundle] of Object.entries(messages)) {
+            const keyBundle = keys[fileKey];
+            for (let i = 0; i < messageBundle.length; i++) {
+                const message = Localization.normalize(messageBundle[i]);
+                const key = keyBundle[i];
+                const localizationKey = this.buildKey(typeof key === 'string' ? key : key.key, fileKey);
+                data.set(message, localizationKey);
+            }
+        }
+        return data;
+    }
+
+    private buildKey(key: string, filepath: string): string {
+        return `vscode/${Localization.transformKey(filepath)}/${key}`;
+    }
+}

package/src/common/path.spec.ts

@@ -257,6 +257,20 @@ describe('Path', () => {
         });
     }
 
+    describe('Normalize path separator', () => {
+        it('should handle windows styled paths', async () => {
+            const path = 'C:\\a\\b\\c';
+            const expected = '/c:/a/b/c';
+            expect(new Path(path).toString()).eq(expected);
+        });
+
+        it('should prefix drive letter with /', async () => {
+            const path = 'c:/a/b/c';
+            const expected = '/c:/a/b/c';
+            expect(new Path(path).toString()).eq(expected);
+        });
+    });
+
     const linuxHome = '/home/test-user';
     const windowsHome = '/C:/Users/test-user';
 
@@ -340,5 +354,6 @@ describe('Path', () => {
             const expected = '~/a/b/theia';
             expect(Path.untildify(path, '')).eq(expected);
         });
+
     });
 });

package/src/common/path.ts

@@ -53,11 +53,22 @@ export class Path {
         } else if (path.length >= 2 && path.charCodeAt(1) === 58 /* ':' */) {
             const code = path.charCodeAt(0);
             if (code >= 65 /* A */ && code <= 90 /* Z */) {
-                path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // "/c:".length === 3
+                path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // "c:".length === 2
+            }
+            if (path.charCodeAt(0) !== 47 /* '/' */) {
+                path = `${String.fromCharCode(47)}${path}`;
             }
         }
         return path;
     }
+    /**
+     * Normalize path separator to use Path.separator
+     * @param Path candidate to normalize
+     * @returns Normalized string path
+     */
+    static normalizePathSeparator(path: string): string {
+        return path.split(/[\\]/).join(Path.separator);
+    }
 
     /**
      * Tildify path, replacing `home` with `~` if user's `home` is present at the beginning of the path.
@@ -112,11 +123,12 @@ export class Path {
     constructor(
         raw: string
     ) {
+        raw = Path.normalizePathSeparator(raw);
         this.raw = Path.normalizeDrive(raw);
-        const firstIndex = raw.indexOf(Path.separator);
-        const lastIndex = raw.lastIndexOf(Path.separator);
+        const firstIndex = this.raw.indexOf(Path.separator);
+        const lastIndex = this.raw.lastIndexOf(Path.separator);
         this.isAbsolute = firstIndex === 0;
-        this.base = lastIndex === -1 ? raw : raw.substr(lastIndex + 1);
+        this.base = lastIndex === -1 ? this.raw : this.raw.substr(lastIndex + 1);
         this.isRoot = this.isAbsolute && firstIndex === lastIndex && (!this.base || Path.isDrive(this.base));
         this.root = this.computeRoot();
 

package/src/common/promise-util.ts

@@ -20,14 +20,14 @@ import { CancellationToken, cancelled } from './cancellation';
  * Simple implementation of the deferred pattern.
  * An object that exposes a promise and functions to resolve and reject it.
  */
-export class Deferred<T> {
+export class Deferred<T = void> {
     state: 'resolved' | 'rejected' | 'unresolved' = 'unresolved';
-    resolve: (value?: T) => void;
+    resolve: (value: T) => void;
     reject: (err?: any) => void; // eslint-disable-line @typescript-eslint/no-explicit-any
 
     promise = new Promise<T>((resolve, reject) => {
         this.resolve = result => {
-            resolve(result as T);
+            resolve(result);
             if (this.state === 'unresolved') {
                 this.state = 'resolved';
             }

package/src/common/quick-pick-service.ts

@@ -13,18 +13,35 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+
+/********************************************************************************
+ * Copyright (c) 2021 SAP SE or an SAP affiliate company 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
+ ********************************************************************************/
+
+import URI from './uri';
+import * as fuzzy from 'fuzzy';
 import { Event } from './event';
-// eslint-disable-next-line @theia/runtime-import-check
-import { QuickInputButtonHandle, QuickPick, QuickPickItem, QuickPickOptions } from '../browser/quick-input/quick-input-service';
+import { KeySequence } from './keys';
+import { CancellationToken } from './cancellation';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
 export interface QuickPickService {
-
     show<T extends QuickPickItem>(items: Array<T>, options?: QuickPickOptions<T>): Promise<T | undefined>;
     setItems<T extends QuickPickItem>(items: Array<T>): void;
     hide(): void
-
     readonly onDidHide: Event<void>;
     readonly onDidAccept: Event<void>;
     readonly onDidChangeValue: Event<{ quickPick: QuickPick<QuickPickItem>, filter: string }>;
@@ -32,3 +49,281 @@ export interface QuickPickService {
     readonly onDidChangeSelection: Event<{ quickPick: QuickPick<QuickPickItem>, selectedItems: Array<QuickPickItem> }>;
     readonly onDidTriggerButton: Event<QuickInputButtonHandle>;
 }
+
+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 QuickPickItemButtonContext<T extends QuickPickItem> extends QuickPickItemButtonEvent<T> {
+    removeItem(): void;
+}
+
+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: QuickPickItemButtonContext<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;
+}

package/src/common/theme.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * Copyright (C) 2017 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
+ ********************************************************************************/
+
+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;
+}
+
+export interface ThemeChangeEvent {
+    readonly newTheme: Theme;
+    readonly oldTheme?: Theme;
+}

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -34,35 +34,35 @@ import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plug
 import '../../../src/electron-browser/menu/electron-menu-style.css';
 
 export namespace ElectronCommands {
-    export const TOGGLE_DEVELOPER_TOOLS = Command.toLocalizedCommand({
+    export const TOGGLE_DEVELOPER_TOOLS = Command.toDefaultLocalizedCommand({
         id: 'theia.toggleDevTools',
         label: 'Toggle Developer Tools'
-    }, 'vscode/developerActions/toggleDevTools');
-    export const RELOAD = Command.toLocalizedCommand({
+    });
+    export const RELOAD = Command.toDefaultLocalizedCommand({
         id: 'view.reload',
         label: 'Reload Window'
-    }, 'vscode/windowActions/reloadWindow');
-    export const ZOOM_IN = Command.toLocalizedCommand({
+    });
+    export const ZOOM_IN = Command.toDefaultLocalizedCommand({
         id: 'view.zoomIn',
         label: 'Zoom In'
-    }, 'vscode/windowActions/zoomIn');
-    export const ZOOM_OUT = Command.toLocalizedCommand({
+    });
+    export const ZOOM_OUT = Command.toDefaultLocalizedCommand({
         id: 'view.zoomOut',
         label: 'Zoom Out'
-    }, 'vscode/windowActions/zoomOut');
-    export const RESET_ZOOM = Command.toLocalizedCommand({
+    });
+    export const RESET_ZOOM = Command.toDefaultLocalizedCommand({
         id: 'view.resetZoom',
         label: 'Reset Zoom'
-    }, 'vscode/windowActions/zoomReset');
-    export const CLOSE_WINDOW = Command.toLocalizedCommand({
+    });
+    export const CLOSE_WINDOW = Command.toDefaultLocalizedCommand({
         id: 'close.window',
         label: 'Close Window'
-    }, 'vscode/windowActions/close');
-    export const TOGGLE_FULL_SCREEN = Command.toLocalizedCommand({
+    });
+    export const TOGGLE_FULL_SCREEN = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.toggleFullScreen',
         category: CommonCommands.VIEW_CATEGORY,
         label: 'Toggle Full Screen'
-    }, 'vscode/windowActions/toggleFullScreen', CommonCommands.VIEW_CATEGORY_KEY);
+    });
 }
 
 export namespace ElectronMenus {
@@ -228,12 +228,12 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
     protected async handleRequiredRestart(): Promise<void> {
         const msgNode = document.createElement('div');
         const message = document.createElement('p');
-        message.textContent = nls.localize('vscode/relauncher.contribution/relaunchSettingMessage', 'A setting has changed that requires a restart to take effect');
+        message.textContent = nls.localizeByDefault('A setting has changed that requires a restart to take effect');
         const detail = document.createElement('p');
-        detail.textContent = nls.localize('vscode/relauncher.contribution/relaunchSettingDetail',
+        detail.textContent = nls.localizeByDefault(
             'Press the restart button to restart {0} and enable the setting.', FrontendApplicationConfigProvider.get().applicationName);
         msgNode.append(message, detail);
-        const restart = nls.localize('vscode/relauncher.contribution/restart', 'Restart');
+        const restart = nls.localizeByDefault('Restart');
         const dialog = new ConfirmDialog({
             title: restart,
             msg: msgNode,

package/src/electron-browser/window/electron-window-preferences.ts

@@ -38,7 +38,7 @@ export const electronWindowPreferencesSchema: PreferenceSchema = {
             'maximum': ZoomLevel.MAX,
             'scope': 'application',
             // eslint-disable-next-line max-len
-            'description': nls.localize('vscode/desktop.contribution/zoomLevel', 'Adjust the zoom level of the window. The original size is 0 and each increment above (e.g. 1.0) or below (e.g. -1.0) represents zooming 20% larger or smaller. You can also enter decimals to adjust the zoom level with a finer granularity.')
+            'description': nls.localizeByDefault('Adjust the zoom level of the window. The original size is 0 and each increment above (e.g. 1.0) or below (e.g. -1.0) represents zooming 20% larger or smaller. You can also enter decimals to adjust the zoom level with a finer granularity.')
         },
         'window.titleBarStyle': {
             type: 'string',
@@ -46,7 +46,7 @@ export const electronWindowPreferencesSchema: PreferenceSchema = {
             default: isWindows ? 'custom' : 'native',
             scope: 'application',
             // eslint-disable-next-line max-len
-            description: nls.localize('vscode/desktop.contribution/titleBarStyle', 'Adjust the appearance of the window title bar. On Linux and Windows, this setting also affects the application and context menu appearances. Changes require a full restart to apply.'),
+            description: nls.localizeByDefault('Adjust the appearance of the window title bar. On Linux and Windows, this setting also affects the application and context menu appearances. Changes require a full restart to apply.'),
             included: !isOSX
         },
     }