@lingui/cli 4.0.0-next.4 → 4.0.0-next.6

package/dist/lingui-extract-experimental.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const conf_1 = require("@lingui/conf");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const formats_1 = require("./api/formats");
+const promises_1 = __importDefault(require("fs/promises"));
+const extractFromFiles_1 = require("./api/catalog/extractFromFiles");
+const utils_1 = require("./api/utils");
+const bundleSource_1 = require("./extract-experimental/bundleSource");
+const writeCatalogs_1 = require("./extract-experimental/writeCatalogs");
+const getEntryPoints_1 = require("./extract-experimental/getEntryPoints");
+const chalk_1 = __importDefault(require("chalk"));
+async function command(linguiConfig, options) {
+    var _a;
+    options.verbose && console.log("Extracting messages from source files…");
+    const config = (_a = linguiConfig.experimental) === null || _a === void 0 ? void 0 : _a.extractor;
+    if (!config) {
+        throw new Error("The configuration for experimental extractor is empty. Please read the docs.");
+    }
+    console.log(chalk_1.default.yellow([
+        "You have using an experimental feature",
+        "Experimental features are not covered by semver, and may cause unexpected or broken application behavior." +
+            " Use at your own risk.",
+        "",
+    ].join("\n")));
+    const tempDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "js-lingui-extract-"));
+    await promises_1.default.rm(tempDir, { recursive: true, force: true });
+    const bundleResult = await (0, bundleSource_1.bundleSource)(config, (0, getEntryPoints_1.getEntryPoints)(config.entries), tempDir, linguiConfig.rootDir);
+    const stats = [];
+    let commandSuccess = true;
+    const format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+    for (const outFile of Object.keys(bundleResult.metafile.outputs)) {
+        const messages = await (0, extractFromFiles_1.extractFromFiles)([outFile], linguiConfig);
+        const { entryPoint } = bundleResult.metafile.outputs[outFile];
+        let output;
+        if (!messages) {
+            commandSuccess = false;
+            continue;
+        }
+        if (options.template) {
+            output = (await (0, writeCatalogs_1.writeTemplate)({
+                linguiConfig,
+                clean: options.clean,
+                format,
+                messages,
+                entryPoint,
+                outputPattern: config.output,
+            })).statMessage;
+        }
+        else {
+            output = (await (0, writeCatalogs_1.writeCatalogs)({
+                locales: options.locales || linguiConfig.locales,
+                linguiConfig,
+                clean: options.clean,
+                format,
+                messages,
+                entryPoint,
+                overwrite: options.overwrite,
+                outputPattern: config.output,
+            })).statMessage;
+        }
+        stats.push({
+            entry: (0, utils_1.normalizeSlashes)(path_1.default.relative(linguiConfig.rootDir, entryPoint)),
+            content: output,
+        });
+    }
+    // cleanup temp directory
+    await promises_1.default.rm(tempDir, { recursive: true, force: true });
+    stats.forEach(({ entry, content }) => {
+        console.log([`Catalog statistics for ${entry}:`, content, ""].join("\n"));
+    });
+    return commandSuccess;
+}
+exports.default = command;
+if (require.main === module) {
+    commander_1.program
+        .option("--config <path>", "Path to the config file")
+        .option("--template", "Extract to template")
+        .option("--overwrite", "Overwrite translations for source locale")
+        .option("--clean", "Remove obsolete translations")
+        .option("--locale <locale, [...]>", "Only extract the specified locales")
+        .option("--verbose", "Verbose output")
+        .parse(process.argv);
+    const options = commander_1.program.opts();
+    const config = (0, conf_1.getConfig)({
+        configPath: options.config,
+    });
+    const result = command(config, {
+        verbose: options.verbose || false,
+        template: options.template,
+        locales: (_a = options.locale) === null || _a === void 0 ? void 0 : _a.split(","),
+        overwrite: options.overwrite,
+        clean: options.clean,
+    }).then(() => {
+        if (!result)
+            process.exit(1);
+    });
+}

package/dist/lingui-extract-template.d.ts

@@ -0,0 +1,6 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+export type CliExtractTemplateOptions = {
+    verbose: boolean;
+    files?: string[];
+};
+export default function command(config: LinguiConfigNormalized, options: Partial<CliExtractTemplateOptions>): Promise<boolean>;

package/dist/lingui-extract-template.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const conf_1 = require("@lingui/conf");
+const api_1 = require("./api");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./api/utils");
+async function command(config, options) {
+    options.verbose && console.log("Extracting messages from source files…");
+    const catalogs = await (0, api_1.getCatalogs)(config);
+    const catalogStats = {};
+    let commandSuccess = true;
+    await Promise.all(catalogs.map(async (catalog) => {
+        const result = await catalog.makeTemplate(Object.assign(Object.assign({}, options), { orderBy: config.orderBy }));
+        if (result) {
+            catalogStats[(0, utils_1.normalizeSlashes)(path_1.default.relative(config.rootDir, catalog.templateFile))] = Object.keys(result).length;
+        }
+        commandSuccess && (commandSuccess = Boolean(result));
+    }));
+    Object.entries(catalogStats).forEach(([key, value]) => {
+        console.log(`Catalog statistics for ${chalk_1.default.bold(key)}: ${chalk_1.default.green(value)} messages`);
+        console.log();
+    });
+    return commandSuccess;
+}
+exports.default = command;
+if (require.main === module) {
+    commander_1.program
+        .option("--config <path>", "Path to the config file")
+        .option("--verbose", "Verbose output")
+        .parse(process.argv);
+    const options = commander_1.program.opts();
+    const config = (0, conf_1.getConfig)({
+        configPath: options.config,
+    });
+    const result = command(config, {
+        verbose: options.verbose || false,
+    }).then(() => {
+        if (!result)
+            process.exit(1);
+    });
+}

package/dist/lingui-extract.d.ts

@@ -0,0 +1,11 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+export type CliExtractOptions = {
+    verbose: boolean;
+    files?: string[];
+    clean: boolean;
+    overwrite: boolean;
+    locale: string;
+    prevFormat: string | null;
+    watch?: boolean;
+};
+export default function command(config: LinguiConfigNormalized, options: Partial<CliExtractOptions>): Promise<boolean>;

package/dist/lingui-extract.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const conf_1 = require("@lingui/conf");
+const api_1 = require("./api");
+const stats_1 = require("./api/stats");
+const help_1 = require("./api/help");
+const ora_1 = __importDefault(require("ora"));
+const utils_1 = require("./api/utils");
+async function command(config, options) {
+    options.verbose && console.log("Extracting messages from source files…");
+    const catalogs = await (0, api_1.getCatalogs)(config);
+    const catalogStats = {};
+    let commandSuccess = true;
+    const spinner = (0, ora_1.default)().start();
+    for (let catalog of catalogs) {
+        const result = await catalog.make(Object.assign(Object.assign({}, options), { orderBy: config.orderBy }));
+        catalogStats[(0, utils_1.normalizeSlashes)(path_1.default.relative(config.rootDir, catalog.path))] = result || {};
+        commandSuccess && (commandSuccess = Boolean(result));
+    }
+    if (commandSuccess) {
+        spinner.succeed();
+    }
+    else {
+        spinner.fail();
+    }
+    Object.entries(catalogStats).forEach(([key, value]) => {
+        console.log(`Catalog statistics for ${key}: `);
+        console.log((0, stats_1.printStats)(config, value).toString());
+        console.log();
+    });
+    if (!options.watch) {
+        console.log(`(use "${chalk_1.default.yellow((0, help_1.helpRun)("extract"))}" to update catalogs with new messages)`);
+        console.log(`(use "${chalk_1.default.yellow((0, help_1.helpRun)("compile"))}" to compile catalogs for production)`);
+    }
+    // If service key is present in configuration, synchronize with cloud translation platform
+    if (typeof config.service === "object" &&
+        config.service.name &&
+        config.service.name.length) {
+        const moduleName = config.service.name.charAt(0).toLowerCase() + config.service.name.slice(1);
+        await import(`./services/${moduleName}`)
+            .then((module) => module.default(config, options))
+            .catch((err) => console.error(`Can't load service module ${moduleName}`, err));
+    }
+    return commandSuccess;
+}
+exports.default = command;
+if (require.main === module) {
+    commander_1.program
+        .option("--config <path>", "Path to the config file")
+        .option("--locale <locale>", "Only extract the specified locale")
+        .option("--overwrite", "Overwrite translations for source locale")
+        .option("--clean", "Remove obsolete translations")
+        .option("--debounce <delay>", "Debounces extraction for given amount of milliseconds")
+        .option("--verbose", "Verbose output")
+        .option("--convert-from <format>", "Convert from previous format of message catalogs")
+        .option("--watch", "Enables Watch Mode")
+        .parse(process.argv);
+    const options = commander_1.program.opts();
+    const config = (0, conf_1.getConfig)({
+        configPath: options.config,
+    });
+    let hasErrors = false;
+    const prevFormat = options.convertFrom;
+    if (prevFormat && config.format === prevFormat) {
+        hasErrors = true;
+        console.error("Trying to migrate message catalog to the same format");
+        console.error(`Set ${chalk_1.default.bold("new")} format in LinguiJS configuration\n` +
+            ` and ${chalk_1.default.bold("previous")} format using --convert-from option.`);
+        console.log();
+        console.log(`Example: Convert from lingui format to minimal`);
+        console.log(chalk_1.default.yellow((0, help_1.helpRun)(`extract --convert-from lingui`)));
+        process.exit(1);
+    }
+    if (options.locale && !config.locales.includes(options.locale)) {
+        hasErrors = true;
+        console.error(`Locale ${chalk_1.default.bold(options.locale)} does not exist.`);
+        console.error();
+    }
+    if (hasErrors)
+        process.exit(1);
+    const extract = (filePath) => {
+        return command(config, {
+            verbose: options.watch || options.verbose || false,
+            clean: options.watch ? false : options.clean || false,
+            overwrite: options.watch || options.overwrite || false,
+            locale: options.locale,
+            watch: options.watch || false,
+            files: (filePath === null || filePath === void 0 ? void 0 : filePath.length) ? filePath : undefined,
+            prevFormat,
+        });
+    };
+    const changedPaths = new Set();
+    let debounceTimer;
+    let previousExtract = Promise.resolve(true);
+    const dispatchExtract = (filePath) => {
+        // Skip debouncing if not enabled but still chain them so no racing issue
+        // on deleting the tmp folder.
+        if (!options.debounce) {
+            previousExtract = previousExtract.then(() => extract(filePath));
+            return previousExtract;
+        }
+        filePath === null || filePath === void 0 ? void 0 : filePath.forEach((path) => changedPaths.add(path));
+        // CLear the previous timer if there is any, and schedule the next
+        debounceTimer && clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            const filePath = [...changedPaths];
+            changedPaths.clear();
+            await extract(filePath);
+        }, options.debounce);
+    };
+    // Check if Watch Mode is enabled
+    if (options.watch) {
+        console.info(chalk_1.default.bold("Initializing Watch Mode..."));
+        (async function initWatch() {
+            const catalogs = await (0, api_1.getCatalogs)(config);
+            let paths = [];
+            let ignored = [];
+            catalogs.forEach((catalog) => {
+                paths.push(...catalog.include);
+                ignored.push(...catalog.exclude);
+            });
+            const watcher = chokidar_1.default.watch(paths, {
+                ignored: ["/(^|[/\\])../", ...ignored],
+                persistent: true,
+            });
+            const onReady = () => {
+                console.info(chalk_1.default.green.bold("Watcher is ready!"));
+                watcher
+                    .on("add", (path) => dispatchExtract([path]))
+                    .on("change", (path) => dispatchExtract([path]));
+            };
+            watcher.on("ready", () => onReady());
+        })();
+    }
+    else if (commander_1.program.args) {
+        // this behaviour occurs when we extract files by his name
+        // for ex: lingui extract src/app, this will extract only files included in src/app
+        extract(commander_1.program.args).then((result) => {
+            if (!result)
+                process.exit(1);
+        });
+    }
+    else {
+        extract().then((result) => {
+            if (!result)
+                process.exit(1);
+        });
+    }
+}

package/dist/lingui.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/lingui.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const node_fs_1 = require("node:fs");
+const packageJson = JSON.parse((0, node_fs_1.readFileSync)("../package.json", "utf8"));
+commander_1.program
+    .version(packageJson.version)
+    .command("extract [files...]", "Extracts messages from source files")
+    .command("extract-experimental", "Extracts messages from source files traversing dependency tree")
+    .command("extract-template", "Extracts messages from source files to a .pot template")
+    .command("compile", "Compile message catalogs")
+    .parse(process.argv);

package/dist/services/translationIO.d.ts

@@ -0,0 +1,3 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { CliExtractOptions } from "../lingui-extract";
+export default function syncProcess(config: LinguiConfigNormalized, options: CliExtractOptions): void;

package/dist/services/translationIO.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const pofile_1 = __importDefault(require("pofile"));
+const https_1 = __importDefault(require("https"));
+const glob_1 = __importDefault(require("glob"));
+const date_fns_1 = require("date-fns");
+const getCreateHeaders = (language) => ({
+    "POT-Creation-Date": (0, date_fns_1.format)(new Date(), "yyyy-MM-dd HH:mmxxxx"),
+    "MIME-Version": "1.0",
+    "Content-Type": "text/plain; charset=utf-8",
+    "Content-Transfer-Encoding": "8bit",
+    "X-Generator": "@lingui/cli",
+    Language: language,
+});
+const getTargetLocales = (config) => {
+    const sourceLocale = config.sourceLocale || "en";
+    const pseudoLocale = config.pseudoLocale || "pseudo";
+    return config.locales.filter((value) => value != sourceLocale && value != pseudoLocale);
+};
+// Main sync method, call "Init" or "Sync" depending on the project context
+function syncProcess(config, options) {
+    if (config.format != "po") {
+        console.error(`\n----------\nTranslation.io service is only compatible with the "po" format. Please update your Lingui configuration accordingly.\n----------`);
+        process.exit(1);
+    }
+    const successCallback = (project) => {
+        console.log(`\n----------\nProject successfully synchronized. Please use this URL to translate: ${project.url}\n----------`);
+    };
+    const failCallback = (errors) => {
+        console.error(`\n----------\nSynchronization with Translation.io failed: ${errors.join(", ")}\n----------`);
+    };
+    init(config, options, successCallback, (errors) => {
+        if (errors.length &&
+            errors[0] === "This project has already been initialized.") {
+            sync(config, options, successCallback, failCallback);
+        }
+        else {
+            failCallback(errors);
+        }
+    });
+}
+exports.default = syncProcess;
+// Initialize project with source and existing translations (only first time!)
+// Cf. https://translation.io/docs/create-library#initialization
+function init(config, options, successCallback, failCallback) {
+    const sourceLocale = config.sourceLocale || "en";
+    const targetLocales = getTargetLocales(config);
+    const paths = poPathsPerLocale(config);
+    const segments = {};
+    targetLocales.forEach((targetLocale) => {
+        segments[targetLocale] = [];
+    });
+    // Create segments from source locale PO items
+    paths[sourceLocale].forEach((path) => {
+        const raw = fs_1.default.readFileSync(path).toString();
+        const po = pofile_1.default.parse(raw);
+        po.items
+            .filter((item) => !item["obsolete"])
+            .forEach((item) => {
+            targetLocales.forEach((targetLocale) => {
+                const newSegment = createSegmentFromPoItem(item);
+                segments[targetLocale].push(newSegment);
+            });
+        });
+    });
+    // Add translations to segments from target locale PO items
+    targetLocales.forEach((targetLocale) => {
+        paths[targetLocale].forEach((path) => {
+            const raw = fs_1.default.readFileSync(path).toString();
+            const po = pofile_1.default.parse(raw);
+            po.items
+                .filter((item) => !item["obsolete"])
+                .forEach((item, index) => {
+                segments[targetLocale][index].target = item.msgstr[0];
+            });
+        });
+    });
+    const request = {
+        client: "lingui",
+        version: require("@lingui/core/package.json").version,
+        source_language: sourceLocale,
+        target_languages: targetLocales,
+        segments: segments,
+    };
+    postTio("init", request, config.service.apiKey, (response) => {
+        if (response.errors) {
+            failCallback(response.errors);
+        }
+        else {
+            saveSegmentsToTargetPos(config, paths, response.segments);
+            successCallback(response.project);
+        }
+    }, (error) => {
+        console.error(`\n----------\nSynchronization with Translation.io failed: ${error}\n----------`);
+    });
+}
+// Send all source text from PO to Translation.io and create new PO based on received translations
+// Cf. https://translation.io/docs/create-library#synchronization
+function sync(config, options, successCallback, failCallback) {
+    const sourceLocale = config.sourceLocale || "en";
+    const targetLocales = getTargetLocales(config);
+    const paths = poPathsPerLocale(config);
+    const segments = [];
+    // Create segments with correct source
+    paths[sourceLocale].forEach((path) => {
+        const raw = fs_1.default.readFileSync(path).toString();
+        const po = pofile_1.default.parse(raw);
+        po.items
+            .filter((item) => !item["obsolete"])
+            .forEach((item) => {
+            const newSegment = createSegmentFromPoItem(item);
+            segments.push(newSegment);
+        });
+    });
+    const request = {
+        client: "lingui",
+        version: require("@lingui/core/package.json").version,
+        source_language: sourceLocale,
+        target_languages: targetLocales,
+        segments: segments,
+        // Sync and then remove unused segments (not present in the local application) from Translation.io
+        purge: Boolean(options.clean),
+    };
+    postTio("sync", request, config.service.apiKey, (response) => {
+        if (response.errors) {
+            failCallback(response.errors);
+        }
+        else {
+            saveSegmentsToTargetPos(config, paths, response.segments);
+            successCallback(response.project);
+        }
+    }, (error) => {
+        console.error(`\n----------\nSynchronization with Translation.io failed: ${error}\n----------`);
+    });
+}
+function createSegmentFromPoItem(item) {
+    const itemHasId = item.msgid != item.msgstr[0] && item.msgstr[0].length;
+    const segment = {
+        type: "source",
+        source: itemHasId ? item.msgstr[0] : item.msgid,
+        context: "",
+        references: [],
+        comment: "",
+    };
+    if (itemHasId) {
+        segment.context = item.msgid;
+    }
+    if (item.references.length) {
+        segment.references = item.references;
+    }
+    if (item.extractedComments.length) {
+        segment.comment = item.extractedComments.join(" | ");
+    }
+    return segment;
+}
+function createPoItemFromSegment(segment) {
+    const item = new pofile_1.default.Item();
+    item.msgid = segment.context ? segment.context : segment.source;
+    item.msgstr = [segment.target];
+    item.references =
+        segment.references && segment.references.length ? segment.references : [];
+    item.extractedComments = segment.comment ? segment.comment.split(" | ") : [];
+    return item;
+}
+function saveSegmentsToTargetPos(config, paths, segmentsPerLocale) {
+    Object.keys(segmentsPerLocale).forEach((targetLocale) => {
+        // Remove existing target POs and JS for this target locale
+        paths[targetLocale].forEach((path) => {
+            const jsPath = path.replace(/\.po?$/, "") + ".js";
+            const dirPath = (0, path_1.dirname)(path);
+            // Remove PO, JS and empty dir
+            if (fs_1.default.existsSync(path)) {
+                fs_1.default.unlinkSync(path);
+            }
+            if (fs_1.default.existsSync(jsPath)) {
+                fs_1.default.unlinkSync(jsPath);
+            }
+            if (fs_1.default.existsSync(dirPath) && fs_1.default.readdirSync(dirPath).length === 0) {
+                fs_1.default.rmdirSync(dirPath);
+            }
+        });
+        // Find target path (ignoring {name})
+        const localePath = "".concat(config.catalogs[0].path
+            .replace(/{locale}/g, targetLocale)
+            .replace(/{name}/g, ""), ".po");
+        const segments = segmentsPerLocale[targetLocale];
+        const po = new pofile_1.default();
+        po.headers = getCreateHeaders(targetLocale);
+        const items = [];
+        segments.forEach((segment) => {
+            const item = createPoItemFromSegment(segment);
+            items.push(item);
+        });
+        // Sort items by messageId
+        po.items = items.sort((a, b) => {
+            if (a.msgid < b.msgid) {
+                return -1;
+            }
+            if (a.msgid > b.msgid) {
+                return 1;
+            }
+            return 0;
+        });
+        // Check that localePath directory exists and save PO file
+        fs_1.default.promises.mkdir((0, path_1.dirname)(localePath), { recursive: true }).then(() => {
+            po.save(localePath, (err) => {
+                if (err) {
+                    console.error("Error while saving target PO files:");
+                    console.error(err);
+                    process.exit(1);
+                }
+            });
+        });
+    });
+}
+function poPathsPerLocale(config) {
+    const paths = {};
+    config.locales.forEach((locale) => {
+        paths[locale] = [];
+        config.catalogs.forEach((catalog) => {
+            const path = "".concat(catalog.path.replace(/{locale}/g, locale).replace(/{name}/g, "*"), ".po");
+            // If {name} is present (replaced by *), list all the existing POs
+            if (path.includes("*")) {
+                paths[locale] = paths[locale].concat(glob_1.default.sync(path));
+            }
+            else {
+                paths[locale].push(path);
+            }
+        });
+    });
+    return paths;
+}
+function postTio(action, request, apiKey, successCallback, failCallback) {
+    const jsonRequest = JSON.stringify(request);
+    const options = {
+        hostname: "translation.io",
+        path: `/api/v1/segments/${action}.json?api_key=${apiKey}`,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    };
+    const req = https_1.default.request(options, (res) => {
+        res.setEncoding("utf8");
+        let body = "";
+        res.on("data", (chunk) => {
+            body = body.concat(chunk);
+        });
+        res.on("end", () => {
+            const response = JSON.parse(body);
+            successCallback(response);
+        });
+    });
+    req.on("error", (e) => {
+        failCallback(e);
+    });
+    req.write(jsonRequest);
+    req.end();
+}