@theia/localization-manager 1.45.0 → 1.46.0-next.72

package/lib/localization-extractor.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=localization-extractor.spec.d.ts.map

package/lib/localization-extractor.spec.js

@@ -1,139 +1,139 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2021 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-only WITH Classpath-exception-2.0
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const localization_extractor_1 = require("./localization-extractor");
-const TEST_FILE = 'test.ts';
-const quiet = { quiet: true };
-describe('correctly extracts from file content', () => {
-    it('should extract from simple nls.localize() call', async () => {
-        const content = 'nls.localize("key", "value")';
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'key': 'value'
-        });
-    });
-    it('should extract from nested nls.localize() call', async () => {
-        const content = 'nls.localize("nested/key", "value")';
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'nested': {
-                'key': 'value'
-            }
-        });
-    });
-    it('should extract IDs from Command.toLocalizedCommand() call', async () => {
-        const content = `
-        Command.toLocalizedCommand({
-            id: 'command-id1',
-            label: 'command-label1'
-        });
-        Command.toLocalizedCommand({
-            id: 'command-id2',
-            label: 'command-label2'
-        }, 'command-key');
-        `;
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'command-id1': 'command-label1',
-            'command-key': 'command-label2'
-        });
-    });
-    it('should extract category from Command.toLocalizedCommand() call', async () => {
-        const content = `
-        Command.toLocalizedCommand({
-            id: 'id',
-            label: 'label',
-            category: 'category'
-        }, undefined, 'category-key');`;
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'id': 'label',
-            'category-key': 'category'
-        });
-    });
-    it('should merge different nls.localize() calls', async () => {
-        const content = `
-        nls.localize('nested/key1', 'value1');
-        nls.localize('nested/key2', 'value2');
-        `;
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'nested': {
-                'key1': 'value1',
-                'key2': 'value2'
-            }
-        });
-    });
-    it('should be able to resolve local references', async () => {
-        const content = `
-        const a = 'key';
-        nls.localize(a, 'value');
-        `;
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
-            'key': 'value'
-        });
-    });
-    it('should return an error when resolving is not successful', async () => {
-        const content = "nls.localize(a, 'value')";
-        const errors = [];
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
-        assert.deepStrictEqual(errors, [
-            "test.ts(1,14): Could not resolve reference to 'a'"
-        ]);
-    });
-    it('should return an error when resolving from an expression', async () => {
-        const content = "nls.localize(test.value, 'value');";
-        const errors = [];
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
-        assert.deepStrictEqual(errors, [
-            "test.ts(1,14): 'test.value' is not a string constant"
-        ]);
-    });
-    it('should show error when trying to merge an object and a string', async () => {
-        const content = `
-        nls.localize('key', 'value');
-        nls.localize('key/nested', 'value');
-        `.trim();
-        const errors = [];
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {
-            'key': 'value'
-        });
-        assert.deepStrictEqual(errors, [
-            "test.ts(2,35): String entry already exists at 'key'"
-        ]);
-    });
-    it('should show error when trying to merge a string into an object', async () => {
-        const content = `
-        nls.localize('key/nested', 'value');
-        nls.localize('key', 'value');
-        `.trim();
-        const errors = [];
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {
-            'key': {
-                'nested': 'value'
-            }
-        });
-        assert.deepStrictEqual(errors, [
-            "test.ts(2,28): Multiple translation keys already exist at 'key'"
-        ]);
-    });
-    it('should show error for template literals', async () => {
-        const content = 'nls.localize("key", `template literal value`)';
-        const errors = [];
-        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
-        assert.deepStrictEqual(errors, [
-            "test.ts(1,20): Template literals are not supported for localization. Please use the additional arguments of the 'nls.localize' function to format strings"
-        ]);
-    });
-});
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2021 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const localization_extractor_1 = require("./localization-extractor");
+const TEST_FILE = 'test.ts';
+const quiet = { quiet: true };
+describe('correctly extracts from file content', () => {
+    it('should extract from simple nls.localize() call', async () => {
+        const content = 'nls.localize("key", "value")';
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'key': 'value'
+        });
+    });
+    it('should extract from nested nls.localize() call', async () => {
+        const content = 'nls.localize("nested/key", "value")';
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'nested': {
+                'key': 'value'
+            }
+        });
+    });
+    it('should extract IDs from Command.toLocalizedCommand() call', async () => {
+        const content = `
+        Command.toLocalizedCommand({
+            id: 'command-id1',
+            label: 'command-label1'
+        });
+        Command.toLocalizedCommand({
+            id: 'command-id2',
+            label: 'command-label2'
+        }, 'command-key');
+        `;
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'command-id1': 'command-label1',
+            'command-key': 'command-label2'
+        });
+    });
+    it('should extract category from Command.toLocalizedCommand() call', async () => {
+        const content = `
+        Command.toLocalizedCommand({
+            id: 'id',
+            label: 'label',
+            category: 'category'
+        }, undefined, 'category-key');`;
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'id': 'label',
+            'category-key': 'category'
+        });
+    });
+    it('should merge different nls.localize() calls', async () => {
+        const content = `
+        nls.localize('nested/key1', 'value1');
+        nls.localize('nested/key2', 'value2');
+        `;
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'nested': {
+                'key1': 'value1',
+                'key2': 'value2'
+            }
+        });
+    });
+    it('should be able to resolve local references', async () => {
+        const content = `
+        const a = 'key';
+        nls.localize(a, 'value');
+        `;
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content), {
+            'key': 'value'
+        });
+    });
+    it('should return an error when resolving is not successful', async () => {
+        const content = "nls.localize(a, 'value')";
+        const errors = [];
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
+        assert.deepStrictEqual(errors, [
+            "test.ts(1,14): Could not resolve reference to 'a'"
+        ]);
+    });
+    it('should return an error when resolving from an expression', async () => {
+        const content = "nls.localize(test.value, 'value');";
+        const errors = [];
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
+        assert.deepStrictEqual(errors, [
+            "test.ts(1,14): 'test.value' is not a string constant"
+        ]);
+    });
+    it('should show error when trying to merge an object and a string', async () => {
+        const content = `
+        nls.localize('key', 'value');
+        nls.localize('key/nested', 'value');
+        `.trim();
+        const errors = [];
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {
+            'key': 'value'
+        });
+        assert.deepStrictEqual(errors, [
+            "test.ts(2,35): String entry already exists at 'key'"
+        ]);
+    });
+    it('should show error when trying to merge a string into an object', async () => {
+        const content = `
+        nls.localize('key/nested', 'value');
+        nls.localize('key', 'value');
+        `.trim();
+        const errors = [];
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {
+            'key': {
+                'nested': 'value'
+            }
+        });
+        assert.deepStrictEqual(errors, [
+            "test.ts(2,28): Multiple translation keys already exist at 'key'"
+        ]);
+    });
+    it('should show error for template literals', async () => {
+        const content = 'nls.localize("key", `template literal value`)';
+        const errors = [];
+        assert.deepStrictEqual(await (0, localization_extractor_1.extractFromFile)(TEST_FILE, content, errors, quiet), {});
+        assert.deepStrictEqual(errors, [
+            "test.ts(1,20): Template literals are not supported for localization. Please use the additional arguments of the 'nls.localize' function to format strings"
+        ]);
+    });
+});
 //# sourceMappingURL=localization-extractor.spec.js.map

package/lib/localization-manager.d.ts

@@ -1,25 +1,25 @@
-import { Localization } from './common';
-import { deepl, DeeplParameters } from './deepl-api';
-export interface LocalizationOptions {
-    freeApi: Boolean;
-    authKey: string;
-    sourceFile: string;
-    sourceLanguage?: string;
-    targetLanguages: string[];
-}
-export declare type LocalizationFunction = (parameters: DeeplParameters) => Promise<string[]>;
-export declare class LocalizationManager {
-    private localizationFn;
-    constructor(localizationFn?: typeof deepl);
-    localize(options: LocalizationOptions): Promise<void>;
-    protected translationFileName(original: string, language: string): string;
-    translateLanguage(source: Localization, target: Localization, targetLanguage: string, options: LocalizationOptions): Promise<void>;
-    protected addIgnoreTags(text: string): string;
-    protected removeIgnoreTags(text: string): string;
-    protected buildLocalizationMap(source: Localization, target: Localization): LocalizationMap;
-}
-export interface LocalizationMap {
-    text: string[];
-    localize: (index: number, value: string) => void;
-}
+import { Localization } from './common';
+import { deepl, DeeplParameters } from './deepl-api';
+export interface LocalizationOptions {
+    freeApi: Boolean;
+    authKey: string;
+    sourceFile: string;
+    sourceLanguage?: string;
+    targetLanguages: string[];
+}
+export declare type LocalizationFunction = (parameters: DeeplParameters) => Promise<string[]>;
+export declare class LocalizationManager {
+    private localizationFn;
+    constructor(localizationFn?: typeof deepl);
+    localize(options: LocalizationOptions): Promise<void>;
+    protected translationFileName(original: string, language: string): string;
+    translateLanguage(source: Localization, target: Localization, targetLanguage: string, options: LocalizationOptions): Promise<void>;
+    protected addIgnoreTags(text: string): string;
+    protected removeIgnoreTags(text: string): string;
+    protected buildLocalizationMap(source: Localization, target: Localization): LocalizationMap;
+}
+export interface LocalizationMap {
+    text: string[];
+    localize: (index: number, value: string) => void;
+}
 //# sourceMappingURL=localization-manager.d.ts.map

package/lib/localization-manager.js

@@ -1,149 +1,149 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2021 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-only WITH Classpath-exception-2.0
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalizationManager = void 0;
-const chalk = require("chalk");
-const fs = require("fs-extra");
-const path = require("path");
-const common_1 = require("./common");
-const deepl_api_1 = require("./deepl-api");
-class LocalizationManager {
-    constructor(localizationFn = deepl_api_1.deepl) {
-        this.localizationFn = localizationFn;
-    }
-    async localize(options) {
-        let source = {};
-        const cwd = process.env.INIT_CWD || process.cwd();
-        const sourceFile = path.resolve(cwd, options.sourceFile);
-        try {
-            source = await fs.readJson(sourceFile);
-        }
-        catch {
-            console.log(chalk.red(`Could not read file "${options.sourceFile}"`));
-            process.exit(1);
-        }
-        const languages = [];
-        for (const targetLanguage of options.targetLanguages) {
-            if (!(0, deepl_api_1.isSupportedLanguage)(targetLanguage)) {
-                console.log(chalk.yellow(`Language "${targetLanguage}" is not supported for automatic localization`));
-            }
-            else {
-                languages.push(targetLanguage);
-            }
-        }
-        if (languages.length !== options.targetLanguages.length) {
-            console.log('Supported languages: ' + deepl_api_1.supportedLanguages.join(', '));
-        }
-        const existingTranslations = new Map();
-        for (const targetLanguage of languages) {
-            try {
-                const targetPath = this.translationFileName(sourceFile, targetLanguage);
-                existingTranslations.set(targetLanguage, await fs.readJson(targetPath));
-            }
-            catch {
-                existingTranslations.set(targetLanguage, {});
-            }
-        }
-        await Promise.all(languages.map(language => this.translateLanguage(source, existingTranslations.get(language), language, options)));
-        for (const targetLanguage of languages) {
-            const targetPath = this.translationFileName(sourceFile, targetLanguage);
-            try {
-                const translation = existingTranslations.get(targetLanguage);
-                await fs.writeJson(targetPath, (0, common_1.sortLocalization)(translation), { spaces: 2 });
-            }
-            catch {
-                console.error(chalk.red(`Error writing translated file to '${targetPath}'`));
-            }
-        }
-    }
-    translationFileName(original, language) {
-        const directory = path.dirname(original);
-        const fileName = path.basename(original, '.json');
-        return path.join(directory, `${fileName}.${language.toLowerCase()}.json`);
-    }
-    async translateLanguage(source, target, targetLanguage, options) {
-        var _a;
-        const map = this.buildLocalizationMap(source, target);
-        if (map.text.length > 0) {
-            try {
-                const translationResponse = await this.localizationFn({
-                    auth_key: options.authKey,
-                    free_api: options.freeApi,
-                    target_lang: targetLanguage.toUpperCase(),
-                    source_lang: (_a = options.sourceLanguage) === null || _a === void 0 ? void 0 : _a.toUpperCase(),
-                    text: map.text.map(e => this.addIgnoreTags(e)),
-                    tag_handling: ['xml'],
-                    ignore_tags: ['x']
-                });
-                translationResponse.translations.forEach(({ text }, i) => {
-                    map.localize(i, this.removeIgnoreTags(text));
-                });
-                console.log(chalk.green(`Successfully translated ${map.text.length} value${map.text.length > 1 ? 's' : ''} for language "${targetLanguage}"`));
-            }
-            catch (e) {
-                console.log(chalk.red(`Could not translate into language "${targetLanguage}"`), e);
-            }
-        }
-        else {
-            console.log(`No translation necessary for language "${targetLanguage}"`);
-        }
-    }
-    addIgnoreTags(text) {
-        return text.replace(/(\{\d*\})/g, '<x>$1</x>');
-    }
-    removeIgnoreTags(text) {
-        return text.replace(/<x>(\{\d+\})<\/x>/g, '$1');
-    }
-    buildLocalizationMap(source, target) {
-        const functionMap = new Map();
-        const text = [];
-        const process = (s, t) => {
-            // Delete all extra keys in the target translation first
-            for (const key of Object.keys(t)) {
-                if (!(key in s)) {
-                    delete t[key];
-                }
-            }
-            for (const [key, value] of Object.entries(s)) {
-                if (!(key in t)) {
-                    if (typeof value === 'string') {
-                        functionMap.set(text.length, translation => t[key] = translation);
-                        text.push(value);
-                    }
-                    else {
-                        const newLocalization = {};
-                        t[key] = newLocalization;
-                        process(value, newLocalization);
-                    }
-                }
-                else if (typeof value === 'object') {
-                    if (typeof t[key] === 'string') {
-                        t[key] = {};
-                    }
-                    process(value, t[key]);
-                }
-            }
-        };
-        process(source, target);
-        return {
-            text,
-            localize: (index, value) => functionMap.get(index)(value)
-        };
-    }
-}
-exports.LocalizationManager = LocalizationManager;
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2021 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationManager = void 0;
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const path = require("path");
+const common_1 = require("./common");
+const deepl_api_1 = require("./deepl-api");
+class LocalizationManager {
+    constructor(localizationFn = deepl_api_1.deepl) {
+        this.localizationFn = localizationFn;
+    }
+    async localize(options) {
+        let source = {};
+        const cwd = process.env.INIT_CWD || process.cwd();
+        const sourceFile = path.resolve(cwd, options.sourceFile);
+        try {
+            source = await fs.readJson(sourceFile);
+        }
+        catch {
+            console.log(chalk.red(`Could not read file "${options.sourceFile}"`));
+            process.exit(1);
+        }
+        const languages = [];
+        for (const targetLanguage of options.targetLanguages) {
+            if (!(0, deepl_api_1.isSupportedLanguage)(targetLanguage)) {
+                console.log(chalk.yellow(`Language "${targetLanguage}" is not supported for automatic localization`));
+            }
+            else {
+                languages.push(targetLanguage);
+            }
+        }
+        if (languages.length !== options.targetLanguages.length) {
+            console.log('Supported languages: ' + deepl_api_1.supportedLanguages.join(', '));
+        }
+        const existingTranslations = new Map();
+        for (const targetLanguage of languages) {
+            try {
+                const targetPath = this.translationFileName(sourceFile, targetLanguage);
+                existingTranslations.set(targetLanguage, await fs.readJson(targetPath));
+            }
+            catch {
+                existingTranslations.set(targetLanguage, {});
+            }
+        }
+        await Promise.all(languages.map(language => this.translateLanguage(source, existingTranslations.get(language), language, options)));
+        for (const targetLanguage of languages) {
+            const targetPath = this.translationFileName(sourceFile, targetLanguage);
+            try {
+                const translation = existingTranslations.get(targetLanguage);
+                await fs.writeJson(targetPath, (0, common_1.sortLocalization)(translation), { spaces: 2 });
+            }
+            catch {
+                console.error(chalk.red(`Error writing translated file to '${targetPath}'`));
+            }
+        }
+    }
+    translationFileName(original, language) {
+        const directory = path.dirname(original);
+        const fileName = path.basename(original, '.json');
+        return path.join(directory, `${fileName}.${language.toLowerCase()}.json`);
+    }
+    async translateLanguage(source, target, targetLanguage, options) {
+        var _a;
+        const map = this.buildLocalizationMap(source, target);
+        if (map.text.length > 0) {
+            try {
+                const translationResponse = await this.localizationFn({
+                    auth_key: options.authKey,
+                    free_api: options.freeApi,
+                    target_lang: targetLanguage.toUpperCase(),
+                    source_lang: (_a = options.sourceLanguage) === null || _a === void 0 ? void 0 : _a.toUpperCase(),
+                    text: map.text.map(e => this.addIgnoreTags(e)),
+                    tag_handling: ['xml'],
+                    ignore_tags: ['x']
+                });
+                translationResponse.translations.forEach(({ text }, i) => {
+                    map.localize(i, this.removeIgnoreTags(text));
+                });
+                console.log(chalk.green(`Successfully translated ${map.text.length} value${map.text.length > 1 ? 's' : ''} for language "${targetLanguage}"`));
+            }
+            catch (e) {
+                console.log(chalk.red(`Could not translate into language "${targetLanguage}"`), e);
+            }
+        }
+        else {
+            console.log(`No translation necessary for language "${targetLanguage}"`);
+        }
+    }
+    addIgnoreTags(text) {
+        return text.replace(/(\{\d*\})/g, '<x>$1</x>');
+    }
+    removeIgnoreTags(text) {
+        return text.replace(/<x>(\{\d+\})<\/x>/g, '$1');
+    }
+    buildLocalizationMap(source, target) {
+        const functionMap = new Map();
+        const text = [];
+        const process = (s, t) => {
+            // Delete all extra keys in the target translation first
+            for (const key of Object.keys(t)) {
+                if (!(key in s)) {
+                    delete t[key];
+                }
+            }
+            for (const [key, value] of Object.entries(s)) {
+                if (!(key in t)) {
+                    if (typeof value === 'string') {
+                        functionMap.set(text.length, translation => t[key] = translation);
+                        text.push(value);
+                    }
+                    else {
+                        const newLocalization = {};
+                        t[key] = newLocalization;
+                        process(value, newLocalization);
+                    }
+                }
+                else if (typeof value === 'object') {
+                    if (typeof t[key] === 'string') {
+                        t[key] = {};
+                    }
+                    process(value, t[key]);
+                }
+            }
+        };
+        process(source, target);
+        return {
+            text,
+            localize: (index, value) => functionMap.get(index)(value)
+        };
+    }
+}
+exports.LocalizationManager = LocalizationManager;
 //# sourceMappingURL=localization-manager.js.map

package/lib/localization-manager.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=localization-manager.spec.d.ts.map