@theia/core 1.18.0 → 1.21.0-next.12

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 = {
+    export const NEW_WINDOW = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.newWindow',
         label: 'New Window'
-    };
+    });
 }
 
 @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

@@ -18,8 +18,7 @@ import { injectable, inject, named } from 'inversify';
 import { Event, Emitter, WaitUntilEvent } from './event';
 import { Disposable, DisposableCollection } from './disposable';
 import { ContributionProvider } from './contribution-provider';
-// eslint-disable-next-line @theia/runtime-import-check
-import { nls } from '../browser/nls';
+import { nls } from './nls';
 
 /**
  * A command is a unique identifier of a function
@@ -65,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

@@ -31,3 +31,57 @@ export interface Localization {
     localizedLanguageName?: string;
     translations: { [key: string]: string };
 }
+
+export type FormatType = string | number | boolean | undefined;
+
+export namespace Localization {
+
+    export function format(message: string, args: FormatType[]): string {
+        let result = message;
+        if (args.length > 0) {
+            result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+                const index = rest[0];
+                const arg = args[index];
+                let replacement = match;
+                if (typeof arg === 'string') {
+                    replacement = arg;
+                } else if (typeof arg === 'number' || typeof arg === 'boolean' || !arg) {
+                    replacement = String(arg);
+                }
+                return replacement;
+            });
+        }
+        return result;
+    }
+
+    export function localize(localization: Localization | undefined, key: string, defaultValue: string, ...args: FormatType[]): string {
+        let value = defaultValue;
+        if (localization) {
+            const translation = localization.translations[key];
+            if (translation) {
+                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('/');
+        if (keySlashIndex >= 0) {
+            nlsKey = key.substring(keySlashIndex + 1);
+        }
+        return nlsKey;
+    }
+}