lingui-po-translate 1.0.0 → 1.0.1

package/dist/file-formats/yaml/yaml-manipulation.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateYmlNodes = exports.extractYmlNodes = void 0;
+const yaml_generic_1 = require("./yaml-generic");
+const flatten_1 = require("../../util/flatten");
+const parse_utils_1 = require("../common/parse-utils");
+function extractYmlNodes(args, document) {
+    const tSet = new Map();
+    const rootContext = {
+        partialKey: "",
+        node: getRootNode(document, args),
+        oldTargetNode: null,
+    };
+    traverseYml(rootContext, (innerContext, scalar) => {
+        const value = scalar.value;
+        if (typeof value === "string") {
+            tSet.set(innerContext.partialKey, value);
+        }
+    });
+    return tSet;
+}
+exports.extractYmlNodes = extractYmlNodes;
+function updateYmlNodes(args) {
+    const rootContext = {
+        partialKey: "",
+        node: getRootNode(args.sourceYml, args.args),
+        oldTargetNode: args.oldTargetYml
+            ? getRootNode(args.oldTargetYml, args.args)
+            : null,
+    };
+    traverseYml(rootContext, (innerContext, scalar) => {
+        const value = args.args.tSet.get(innerContext.partialKey);
+        if (value !== undefined) {
+            scalar.value = value;
+        }
+    });
+}
+exports.updateYmlNodes = updateYmlNodes;
+function getRootNode(document, args) {
+    const root = document.contents;
+    if (!root) {
+        (0, parse_utils_1.logParseError)("root node not found", args);
+    }
+    if (!(0, yaml_generic_1.isScalar)(root) && !(0, yaml_generic_1.isCollection)(root) && !(0, yaml_generic_1.isPair)(root)) {
+        (0, parse_utils_1.logParseError)("root node invalid", args);
+    }
+    return root;
+}
+function traverseYml(context, operation) {
+    var _a, _b, _c, _d;
+    const node = context.node;
+    if (!node) {
+        return;
+    }
+    if (((_a = context.oldTargetNode) === null || _a === void 0 ? void 0 : _a.type) !== node.type) {
+        context.oldTargetNode = null;
+    }
+    if ((_b = context.oldTargetNode) === null || _b === void 0 ? void 0 : _b.comment) {
+        node.comment = context.oldTargetNode.comment;
+    }
+    if ((_c = context.oldTargetNode) === null || _c === void 0 ? void 0 : _c.commentBefore) {
+        node.commentBefore = context.oldTargetNode.commentBefore;
+    }
+    if ((_d = context.oldTargetNode) === null || _d === void 0 ? void 0 : _d.spaceBefore) {
+        node.spaceBefore = context.oldTargetNode.spaceBefore;
+    }
+    // if (context.oldTargetNode?.cstNode) {
+    //   node.cstNode = context.oldTargetNode.cstNode;
+    // }
+    if ((0, yaml_generic_1.isScalar)(node)) {
+        operation(context, node);
+    }
+    if ((0, yaml_generic_1.isPair)(node)) {
+        const pairKey = getPairKey(node);
+        let partialKey;
+        if (context.partialKey.length) {
+            partialKey = context.partialKey + flatten_1.NESTED_JSON_SEPARATOR + pairKey;
+        }
+        else {
+            partialKey = pairKey;
+        }
+        let oldTargetPair = null;
+        if ((0, yaml_generic_1.isPair)(context.oldTargetNode) &&
+            getPairKey(context.oldTargetNode) === pairKey) {
+            oldTargetPair = context.oldTargetNode;
+        }
+        traverseYml({
+            node: node.value,
+            oldTargetNode: oldTargetPair
+                ? oldTargetPair.value
+                : null,
+            partialKey,
+        }, operation);
+    }
+    if ((0, yaml_generic_1.isCollection)(node)) {
+        node.items.forEach((childNode, idx) => {
+            let partialKey = `${context.partialKey}`;
+            if ((0, yaml_generic_1.isSequence)(node)) {
+                partialKey += `[${idx}]`;
+            }
+            let oldTargetChild = null;
+            if ((0, yaml_generic_1.isCollection)(context.oldTargetNode)) {
+                oldTargetChild = findMatchingOldTargetChild(context.oldTargetNode.items, childNode, idx);
+            }
+            traverseYml({
+                node: childNode,
+                oldTargetNode: oldTargetChild,
+                partialKey: partialKey,
+            }, operation);
+        });
+    }
+}
+function findMatchingOldTargetChild(oldTargetItems, child, idx) {
+    if (!(0, yaml_generic_1.isPair)(child)) {
+        if (idx >= oldTargetItems.length) {
+            return null;
+        }
+        return oldTargetItems[idx];
+    }
+    else {
+        const candidatePairs = oldTargetItems.filter((node) => (0, yaml_generic_1.isPair)(node));
+        const matchingPair = candidatePairs.find((pair) => getPairKey(pair) === getPairKey(child));
+        return matchingPair !== null && matchingPair !== void 0 ? matchingPair : null;
+    }
+}
+function getPairKey(pair) {
+    var _a;
+    if (typeof pair.key === "string") {
+        return pair.key;
+    }
+    return (_a = pair.key) === null || _a === void 0 ? void 0 : _a.value;
+}

package/dist/file-formats/yaml/yaml-parse.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = void 0;
+const yaml_1 = require("yaml");
+const parse_utils_1 = require("../common/parse-utils");
+const managed_utf8_1 = require("../common/managed-utf8");
+function parseYaml(args) {
+    var _a;
+    const ymlString = (0, managed_utf8_1.readManagedUtf8)(args.path);
+    if (!ymlString) {
+        return null;
+    }
+    const options = {
+        keepCstNodes: true,
+        keepNodeTypes: true,
+        keepUndefined: true,
+        prettyErrors: true,
+    };
+    let document;
+    try {
+        document = (0, yaml_1.parseDocument)(ymlString, options);
+    }
+    catch (e) {
+        console.error(e);
+        (0, parse_utils_1.logParseError)("YAML parsing error", args);
+    }
+    if ((_a = document.errors) === null || _a === void 0 ? void 0 : _a.length) {
+        const errorMsg = document.errors
+            .map((e) => {
+            e.makePretty();
+            return e.message;
+        })
+            .join("\n");
+        (0, parse_utils_1.logParseError)(errorMsg, args);
+    }
+    return document;
+}
+exports.parseYaml = parseYaml;

package/dist/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const tslib_1 = require("tslib");
+const commander_1 = (0, tslib_1.__importDefault)(require("commander"));
+require("dotenv/config");
+const translate_cli_1 = require("./core/translate-cli");
+const file_format_definitions_1 = require("./file-formats/file-format-definitions");
+const matcher_definitions_1 = require("./matchers/matcher-definitions");
+const service_definitions_1 = require("./services/service-definitions");
+const extract_version_1 = require("./util/extract-version");
+process.on("unhandledRejection", (error) => {
+    console.error("[fatal]", error);
+});
+function formatOneOfOptions(options) {
+    return `One of ${(0, translate_cli_1.formatCliOptions)(options)}`;
+}
+function run(process, cliBinDir) {
+    var _a;
+    commander_1.default.storeOptionsAsProperties(false);
+    commander_1.default.addHelpCommand(false);
+    commander_1.default
+        .requiredOption("--srcFile <sourceFile>", "The source file to be translated")
+        .requiredOption("--srcLng <sourceLanguage>", "A language code for the source language")
+        .requiredOption("--srcFormat <sourceFileFormat>", formatOneOfOptions((0, file_format_definitions_1.getTFileFormatList)()))
+        .requiredOption("--targetFile <targetFile>", "The target file for the translations")
+        .requiredOption("--targetLng <targetLanguage>", "A language code for the target language")
+        .requiredOption("--targetFormat <targetFileFormat>", formatOneOfOptions((0, file_format_definitions_1.getTFileFormatList)()))
+        .requiredOption("--service <translationService>", formatOneOfOptions((0, service_definitions_1.getTServiceList)()))
+        .option("--serviceConfig <serviceKey>", "supply configuration for a translation service (either a path to a key-file or an API-key)")
+        .option("--matcher <matcher>", formatOneOfOptions((0, matcher_definitions_1.getTMatcherList)()), "none")
+        .option("--prompt <prompt>", "supply a prompt for the AI translation service")
+        .option("--sourceOverride <mapping>", "override source language for specific targets (e.g., 'zh-Hant:zh-Hans,pt-BR:pt-PT')")
+        .option("--baseUrl <url>", "custom API base URL for OpenAI-compatible services (e.g., 'https://api.openai.com/v1')")
+        .version((0, extract_version_1.extractVersion)({ cliBinDir }), "-v, --version")
+        .parse(process.argv);
+    if ((_a = commander_1.default.args) === null || _a === void 0 ? void 0 : _a.length) {
+        // Args are not permitted, only work with options.
+        commander_1.default.unknownCommand();
+    }
+    const args = {
+        srcFile: commander_1.default.opts().srcFile,
+        srcLng: commander_1.default.opts().srcLng,
+        srcFormat: commander_1.default.opts().srcFormat,
+        targetFile: commander_1.default.opts().targetFile,
+        targetLng: commander_1.default.opts().targetLng,
+        targetFormat: commander_1.default.opts().targetFormat,
+        service: commander_1.default.opts().service,
+        serviceConfig: commander_1.default.opts().serviceConfig,
+        matcher: commander_1.default.opts().matcher,
+        prompt: commander_1.default.opts().prompt,
+        sourceOverride: commander_1.default.opts().sourceOverride,
+        baseUrl: commander_1.default.opts().baseUrl,
+    };
+    (0, translate_cli_1.translateCli)(args)
+        .then(() => {
+        process.exit(0);
+    })
+        .catch((e) => {
+        console.error("An error occurred:");
+        console.error(e.message);
+        console.error(e.stack);
+        process.exit(1);
+    });
+}
+exports.run = run;

package/dist/matchers/i18next.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchI18Next = void 0;
+const matchI18Next = (input, replacer) => {
+    const matches = input.match(/(\{\{.+?\}\}|\$t\(.+?\)|\$\{.+?\})/g);
+    return (matches || []).map((match, index) => ({
+        from: match,
+        to: replacer(index),
+    }));
+};
+exports.matchI18Next = matchI18Next;

package/dist/matchers/icu.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchIcu = void 0;
+let parseModule = null;
+const matchIcu = (input, replacer) => {
+    // Import parseModule on demand to optimize launch-performance.
+    if (!parseModule) {
+        parseModule = require("messageformat-parser");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const parts = parseModule.parse(input);
+    const regex = new RegExp(parts
+        .map((part) => typeof part === "string"
+        ? part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        : "(.*)")
+        .join(""));
+    const matches = input.match(regex);
+    return (matches || []).slice(1).map((match, index) => ({
+        from: match,
+        to: replacer(index),
+    }));
+};
+exports.matchIcu = matchIcu;

package/dist/matchers/matcher-definitions.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantiateTMatcher = exports.reInsertInterpolations = exports.replaceInterpolations = exports.getTMatcherList = exports.matchNothing = exports.xmlStyleReplacer = void 0;
+const icu_1 = require("./icu");
+const i18next_1 = require("./i18next");
+const sprintf_1 = require("./sprintf");
+const xmlStyleReplacer = (index) => `<span>${index}</span>`;
+exports.xmlStyleReplacer = xmlStyleReplacer;
+const xmlLeftTag = "<span>";
+const xmlRightTag = "</span>";
+const spaceXmlRightTag = "</ span>";
+const matchNothing = () => [];
+exports.matchNothing = matchNothing;
+function getTMatcherList() {
+    return Object.keys(matcherMap);
+}
+exports.getTMatcherList = getTMatcherList;
+const matcherMap = {
+    none: exports.matchNothing,
+    icu: icu_1.matchIcu,
+    i18next: i18next_1.matchI18Next,
+    sprintf: sprintf_1.matchSprintf,
+};
+const replaceInterpolations = (input, matcher = exports.matchNothing, replacer = exports.xmlStyleReplacer) => {
+    const replacements = matcher(input, replacer);
+    const clean = replacements.reduce((acc, cur) => acc.replace(cur.from, cur.to), input);
+    return { clean, replacements };
+};
+exports.replaceInterpolations = replaceInterpolations;
+function replaceAll(string, search, replace) {
+    return string.split(search).join(replace);
+}
+const reInsertInterpolations = (clean, replacements) => {
+    const c1 = replaceAll(clean, xmlLeftTag + " ", xmlLeftTag);
+    const c2 = replaceAll(c1, spaceXmlRightTag, xmlRightTag);
+    const c3 = replaceAll(c2, " " + xmlRightTag, xmlRightTag);
+    return replacements.reduce((acc, cur) => acc.replace(cur.to, cur.from), c3);
+};
+exports.reInsertInterpolations = reInsertInterpolations;
+function instantiateTMatcher(matcher) {
+    if (typeof matcherMap[matcher] === "undefined") {
+        throw new Error(`matcher ${matcher} doesn't exist.`);
+    }
+    return matcherMap[matcher];
+}
+exports.instantiateTMatcher = instantiateTMatcher;

package/dist/matchers/sprintf.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSprintf = void 0;
+const matchSprintf = (input, replacer) => {
+    const matches = input.match(/(%.)/g);
+    return (matches || []).map((match, index) => ({
+        from: match,
+        to: replacer(index),
+    }));
+};
+exports.matchSprintf = matchSprintf;

package/dist/services/azure-translator.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureTranslator = void 0;
+const tslib_1 = require("tslib");
+const node_fetch_1 = (0, tslib_1.__importDefault)(require("node-fetch"));
+const lodash_1 = require("lodash");
+const util_1 = require("../util/util");
+const TRANSLATE_ENDPOINT = "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0";
+class AzureTranslator {
+    async translateBatch(batch, args, config) {
+        var _a;
+        const [apiKey, region] = (_a = config === null || config === void 0 ? void 0 : config.split(',')) !== null && _a !== void 0 ? _a : [];
+        if (!apiKey) {
+            throw new Error('Missing API Key');
+        }
+        const headers = {
+            "Ocp-Apim-Subscription-Key": apiKey,
+            "Content-Type": "application/json; charset=UTF-8",
+        };
+        if (region) {
+            headers["Ocp-Apim-Subscription-Region"] = region;
+        }
+        const azureBody = batch.map((tString) => {
+            return {
+                Text: tString.value,
+            };
+        });
+        const response = await (0, node_fetch_1.default)(`${TRANSLATE_ENDPOINT}&from=${args.srcLng}&to=${args.targetLng}&textType=html`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(azureBody),
+        });
+        if (!response.ok) {
+            throw new Error("Azure Translation failed: " + (await response.text()));
+        }
+        const data = (await response.json());
+        return data.map((res, i) => ({
+            key: batch[i].key,
+            translated: res.translations[0].text,
+        }));
+    }
+    async translateStrings(args) {
+        const config = args.serviceConfig;
+        if (!config) {
+            (0, util_1.logFatal)("Set '--serviceConfig' to an Azure API key");
+        }
+        const batches = (0, lodash_1.chunk)(args.strings, 50);
+        const results = await Promise.all(batches.map((batch) => this.translateBatch(batch, args, config)));
+        return (0, lodash_1.flatten)(results);
+    }
+}
+exports.AzureTranslator = AzureTranslator;

package/dist/services/google-translate.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleTranslate = void 0;
+const translate_1 = require("@google-cloud/translate");
+const util_1 = require("../util/util");
+const lodash_1 = require("lodash");
+const managed_json_1 = require("../file-formats/common/managed-json");
+class GoogleTranslate {
+    async translateStrings(args) {
+        if (!args.serviceConfig) {
+            (0, util_1.logFatal)("Set '--serviceConfig' to a path that points to a GCloud service account JSON file");
+        }
+        (0, util_1.checkNotDir)(args.serviceConfig, { errorHint: "serviceConfig" });
+        const keyFile = (0, managed_json_1.readRawJson)(args.serviceConfig).object;
+        if (!keyFile.project_id) {
+            (0, util_1.logFatal)(`serviceConfig ${(0, util_1.getDebugPath)(args.serviceConfig)} does not contain a project_id`);
+        }
+        const projectId = keyFile.project_id;
+        const clientOptions = {
+            keyFile: args.serviceConfig,
+        };
+        const client = new translate_1.TranslationServiceClient(clientOptions);
+        const batches = (0, lodash_1.chunk)(args.strings, 10);
+        const results = await Promise.all(batches.map((batch) => this.translateBatch(batch, client, args, projectId)));
+        return (0, lodash_1.flatten)(results);
+    }
+    async translateBatch(batch, client, args, projectId) {
+        const location = "global";
+        const stringsToTranslate = batch.map((tString) => tString.value);
+        const request = {
+            parent: `projects/${projectId}/locations/${location}`,
+            contents: stringsToTranslate,
+            mimeType: "text/plain",
+            sourceLanguageCode: args.srcLng,
+            targetLanguageCode: args.targetLng,
+        };
+        const [response] = await client.translateText(request);
+        if (!response.translations) {
+            (0, util_1.logFatal)(`Google-translate did not return translations`);
+        }
+        return response.translations.map((value, index) => {
+            return this.transformGCloudResult(value, batch[index]);
+        });
+    }
+    transformGCloudResult(result, input) {
+        if (!result.translatedText) {
+            (0, util_1.logFatal)(`Google-translate did not return a result for input '${input.value}' with key '${input.key}'`);
+        }
+        return {
+            key: input.key,
+            translated: result.translatedText,
+        };
+    }
+}
+exports.GoogleTranslate = GoogleTranslate;

package/dist/services/key-as-translation.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyAsTranslation = void 0;
+const util_1 = require("../util/util");
+class KeyAsTranslation {
+    translateStrings(args) {
+        if (args.srcLng !== args.targetLng) {
+            (0, util_1.logFatal)(`'key-as-translation' cannot translate between different languages -> You should either use equal languages or a different service`);
+        }
+        return Promise.resolve(args.strings.map((tString) => {
+            return {
+                key: tString.key,
+                translated: tString.key,
+            };
+        }));
+    }
+}
+exports.KeyAsTranslation = KeyAsTranslation;

package/dist/services/manual.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualTranslation = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = (0, tslib_1.__importDefault)(require("inquirer"));
+class ManualTranslation {
+    async translateStrings(args) {
+        const results = [];
+        console.info(`Total number of questions: ${args.strings.length}`);
+        console.info(`You can skip questions by pressing <ENTER> without any other character.`);
+        for (const { key, value } of args.strings) {
+            const result = await inquirer_1.default.prompt([
+                {
+                    name: "result",
+                    message: `(${key}) What is '${value}' in '${args.targetLng}'?`,
+                },
+            ]);
+            const userInput = result.result;
+            if (userInput.trim().length) {
+                results.push({
+                    key,
+                    translated: result.result,
+                });
+            }
+        }
+        return results;
+    }
+}
+exports.ManualTranslation = ManualTranslation;

package/dist/services/openai-translate.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAITranslate = void 0;
+const openai_1 = require("openai");
+const util_1 = require("../util/util");
+const lodash_1 = require("lodash");
+async function translateSingleString(tString, args) {
+    var _a, _b, _c, _d;
+    const OPENAI_API_KEY = args.serviceConfig;
+    if (!OPENAI_API_KEY || !OPENAI_API_KEY.trim().length) {
+        (0, util_1.logFatal)('Missing OpenAI API Key: Please get an API key from https://platform.openai.com/account/api-keys and then call lingui-po-translate with --serviceConfig="YOUR API KEY"');
+    }
+    const configuration = new openai_1.Configuration({
+        apiKey: OPENAI_API_KEY,
+        basePath: (_b = (_a = args.baseUrl) !== null && _a !== void 0 ? _a : process.env.OPENAI_BASE_URL) !== null && _b !== void 0 ? _b : undefined,
+    });
+    const openai = new openai_1.OpenAIApi(configuration);
+    const prompt = generatePrompt(tString, args);
+    const messages = [
+        {
+            role: "user",
+            content: prompt,
+        },
+    ];
+    /**
+     * https://platform.openai.com/docs/api-reference/completions/create
+     * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+     * We generally recommend altering this or top_p but not both.
+     */
+    try {
+        const completion = await openai.createChatCompletion({
+            model: "gpt-4o-mini-2024-07-18",
+            messages: messages,
+            temperature: 0,
+            max_tokens: 2048,
+        });
+        const text = (_c = completion.data.choices[0].message) === null || _c === void 0 ? void 0 : _c.content;
+        if (text == undefined) {
+            (0, util_1.logFatal)("OpenAI returned undefined for prompt " + prompt);
+        }
+        return text;
+    }
+    catch (e) {
+        if (typeof e.message === "string") {
+            (0, util_1.logFatal)("OpenAI: " +
+                e.message +
+                ", Status text: " +
+                JSON.stringify((_d = e === null || e === void 0 ? void 0 : e.response) === null || _d === void 0 ? void 0 : _d.statusText));
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function generatePrompt(tString, args) {
+    const capitalizedText = tString.value;
+    const initialPrompt = `only translate my software string from ${args.srcLng} to ${args.targetLng}. don't chat or explain. Using the correct terms for computer software in the target language, only show target language never repeat string. if you don't find something to translate, don't respond`;
+    let contextInfo = `\n\nkey (used for context): ${tString.key}`;
+    if (tString.context) {
+        contextInfo += `\n\ncontext: ${tString.context}`;
+    }
+    return (initialPrompt +
+        (args.prompt ? `\n\n${args.prompt}` : "") +
+        contextInfo +
+        `\n\nstring to translate: ${capitalizedText}`);
+}
+async function translateBatch(batch, args) {
+    console.log("Translate a batch of " + batch.length + " strings with OpenAI...");
+    const promises = batch.map(async (tString) => {
+        const rawResult = await translateSingleString(tString, args);
+        const result = {
+            key: tString.key,
+            translated: rawResult.trim(),
+        };
+        return result;
+    });
+    const resolvedPromises = await Promise.all(promises);
+    return resolvedPromises;
+}
+class OpenAITranslate {
+    async translateStrings(args) {
+        const batches = (0, lodash_1.chunk)(args.strings, 10);
+        const results = [];
+        for (const batch of batches) {
+            const result = await translateBatch(batch, args);
+            results.push(result);
+        }
+        return (0, lodash_1.flatten)(results);
+    }
+}
+exports.OpenAITranslate = OpenAITranslate;

package/dist/services/service-definitions.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantiateTService = exports.injectFakeService = exports.getTServiceList = void 0;
+const util_1 = require("../util/util");
+function getTServiceList() {
+    return Object.keys(serviceMap);
+}
+exports.getTServiceList = getTServiceList;
+const serviceMap = {
+    openai: null,
+    typechat: null,
+    "typechat-manual": null,
+    manual: null,
+    "sync-without-translate": null,
+    "google-translate": null,
+    // deepl: null,
+    azure: null,
+    "key-as-translation": null,
+};
+function injectFakeService(serviceName, service) {
+    fakeServiceMap[serviceName] = service;
+}
+exports.injectFakeService = injectFakeService;
+const fakeServiceMap = {};
+async function instantiateTService(service) {
+    const fakeService = fakeServiceMap[service];
+    if (fakeService) {
+        return fakeService;
+    }
+    /**
+     * To gain a reasonable launch-performance, we import services dynamically.
+     * This is especially important for google-translate, which uses a huge bunch of packages.
+     */
+    switch (service) {
+        case "openai":
+            return new (await Promise.resolve().then(() => __importStar(require("./openai-translate")))).OpenAITranslate();
+        case "typechat":
+            (0, util_1.nodeVersionSatisfies)("typechat", ">=18");
+            return new (await Promise.resolve().then(() => __importStar(require("./typechat")))).TypeChatTranslate();
+        case "typechat-manual":
+            (0, util_1.nodeVersionSatisfies)("typechat", ">=18");
+            return new (await Promise.resolve().then(() => __importStar(require("./typechat")))).TypeChatTranslate(true);
+        case "azure":
+            return new (await Promise.resolve().then(() => __importStar(require("./azure-translator")))).AzureTranslator();
+        // case "deepl":
+        //   return new (await import("./deepl")).DeepL();
+        case "google-translate":
+            return new (await Promise.resolve().then(() => __importStar(require("./google-translate")))).GoogleTranslate();
+        case "manual":
+            return new (await Promise.resolve().then(() => __importStar(require("./manual")))).ManualTranslation();
+        case "sync-without-translate":
+            return new (await Promise.resolve().then(() => __importStar(require("./sync-without-translate")))).SyncWithoutTranslate();
+        case "key-as-translation":
+            return new (await Promise.resolve().then(() => __importStar(require("./key-as-translation")))).KeyAsTranslation();
+    }
+}
+exports.instantiateTService = instantiateTService;

package/dist/services/sync-without-translate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncWithoutTranslate = void 0;
+const util_1 = require("../util/util");
+class SyncWithoutTranslate {
+    translateStrings(args) {
+        if (args.srcLng !== args.targetLng) {
+            (0, util_1.logFatal)(`'sync-without-translate' cannot translate between different languages -> You should either use equal languages or a different service`);
+        }
+        return Promise.resolve(args.strings.map((tString) => {
+            return {
+                key: tString.key,
+                translated: tString.value,
+            };
+        }));
+    }
+}
+exports.SyncWithoutTranslate = SyncWithoutTranslate;