@lingui/cli 5.4.1 → 5.5.1

package/dist/api/workerLogger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerLogger = void 0;
+class WorkerLogger {
+    constructor() {
+        this.errors = [];
+    }
+    error(msg) {
+        this.errors.push(msg);
+    }
+    flush() {
+        const errors = this.errors.join("\n");
+        this.errors = [];
+        return {
+            errors,
+        };
+    }
+}
+exports.WorkerLogger = WorkerLogger;

package/dist/extract-experimental/extractFromBundleAndWrite.d.ts

@@ -0,0 +1,19 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { FormatterWrapper } from "../api/formats";
+export declare function extractFromBundleAndWrite(params: {
+    entryPoint: string;
+    bundleFile: string;
+    linguiConfig: LinguiConfigNormalized;
+    outputPattern: string;
+    format: FormatterWrapper;
+    template: boolean;
+    locales: string[];
+    clean: boolean;
+    overwrite: boolean;
+}): Promise<{
+    success: boolean;
+    stat?: undefined;
+} | {
+    success: boolean;
+    stat: string;
+}>;

package/dist/extract-experimental/extractFromBundleAndWrite.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFromBundleAndWrite = extractFromBundleAndWrite;
+const extractFromFiles_1 = require("../api/catalog/extractFromFiles");
+const writeCatalogs_1 = require("./writeCatalogs");
+const promises_1 = __importDefault(require("fs/promises"));
+const babel_1 = require("../api/extractors/babel");
+async function extractFromBundle(filename, linguiConfig) {
+    const messages = {};
+    let success;
+    try {
+        const file = await promises_1.default.readFile(filename);
+        const parserOptions = linguiConfig.extractorParserOptions;
+        await (0, babel_1.extractFromFileWithBabel)(filename, file.toString(), (msg) => {
+            (0, extractFromFiles_1.mergeExtractedMessage)(msg, messages, linguiConfig);
+        }, {
+            linguiConfig,
+        }, {
+            plugins: (0, babel_1.getBabelParserOptions)(filename, parserOptions),
+        }, true);
+        success = true;
+    }
+    catch (e) {
+        console.error(`Cannot process file ${filename} ${e.message}`);
+        console.error(e.stack);
+        success = false;
+    }
+    return { success, messages };
+}
+async function extractFromBundleAndWrite(params) {
+    const { linguiConfig, entryPoint, format, outputPattern, locales, overwrite, clean, template, } = params;
+    const { messages, success } = await extractFromBundle(params.bundleFile, params.linguiConfig);
+    if (!success) {
+        return { success: false };
+    }
+    let stat;
+    if (template) {
+        stat = (await (0, writeCatalogs_1.writeTemplate)({
+            linguiConfig,
+            clean,
+            format,
+            messages,
+            entryPoint,
+            outputPattern,
+        })).statMessage;
+    }
+    else {
+        stat = (await (0, writeCatalogs_1.writeCatalogs)({
+            locales,
+            linguiConfig,
+            clean,
+            format,
+            messages,
+            entryPoint,
+            overwrite,
+            outputPattern,
+        })).statMessage;
+    }
+    return { success: true, stat };
+}

package/dist/extract-experimental/workers/extractWorker.d.ts

@@ -0,0 +1,6 @@
+export type ExtractWorkerFunction = typeof extractWorker;
+declare const extractWorker: (linguiConfigPath: string, entryPoint: string, bundleFile: string, outputPattern: string, template: boolean, locales: string[], clean: boolean, overwrite: boolean) => Promise<{
+    success: boolean;
+    stat?: string;
+}>;
+export {};

package/dist/extract-experimental/workers/extractWorker.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_1 = require("threads/worker");
+const conf_1 = require("@lingui/conf");
+const extractFromBundleAndWrite_1 = require("../extractFromBundleAndWrite");
+const formats_1 = require("../../api/formats");
+let linguiConfig;
+let format;
+const extractWorker = async (linguiConfigPath, entryPoint, bundleFile, outputPattern, template, locales, clean, overwrite) => {
+    if (!linguiConfig) {
+        // initialize config once per worker, speed up workers follow execution
+        linguiConfig = (0, conf_1.getConfig)({
+            configPath: linguiConfigPath,
+            skipValidation: true,
+        });
+    }
+    if (!format) {
+        format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+    }
+    return await (0, extractFromBundleAndWrite_1.extractFromBundleAndWrite)({
+        entryPoint,
+        bundleFile,
+        outputPattern,
+        format,
+        linguiConfig,
+        locales,
+        overwrite,
+        clean,
+        template,
+    });
+};
+(0, worker_1.expose)(extractWorker);

package/dist/lingui-compile.d.ts

@@ -1,4 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
+import { WorkersOptions } from "./api/resolveWorkersOptions";
 export type CliCompileOptions = {
     verbose?: boolean;
     allowEmpty?: boolean;
@@ -6,5 +7,6 @@ export type CliCompileOptions = {
     typescript?: boolean;
     watch?: boolean;
     namespace?: string;
+    workersOptions: WorkersOptions;
 };
 export declare function command(config: LinguiConfigNormalized, options: CliCompileOptions): Promise<boolean>;

package/dist/lingui-compile.js

@@ -8,111 +8,75 @@ const picocolors_1 = __importDefault(require("picocolors"));
 const chokidar_1 = __importDefault(require("chokidar"));
 const commander_1 = require("commander");
 const conf_1 = require("@lingui/conf");
-const compile_1 = require("./api/compile");
 const help_1 = require("./api/help");
 const api_1 = require("./api");
-const getCatalogs_1 = require("./api/catalog/getCatalogs");
-const normalize_path_1 = __importDefault(require("normalize-path"));
-const path_1 = __importDefault(require("path"));
-class ProgramExit extends Error {
-}
+const compileLocale_1 = require("./api/compile/compileLocale");
+const threads_1 = require("threads");
+const resolveWorkersOptions_1 = require("./api/resolveWorkersOptions");
+const ms_1 = __importDefault(require("ms"));
 async function command(config, options) {
-    const catalogs = await (0, api_1.getCatalogs)(config);
+    const startTime = Date.now();
     // Check config.compile.merge if catalogs for current locale are to be merged into a single compiled file
     const doMerge = !!config.catalogsMergePath;
     console.log("Compiling message catalogs…");
     let errored = false;
-    await Promise.all(config.locales.map(async (locale) => {
-        try {
-            await compileLocale(locale, catalogs, options, config, doMerge);
-        }
-        catch (err) {
-            if (err instanceof ProgramExit) {
-                errored = true;
-            }
-            else {
-                throw err;
-            }
-        }
-    }));
-    return !errored;
-}
-async function compileLocale(locale, catalogs, options, config, doMerge) {
-    let mergedCatalogs = {};
-    await Promise.all(catalogs.map(async (catalog) => {
-        const { messages, missing: missingMessages } = await catalog.getTranslations(locale, {
-            fallbackLocales: config.fallbackLocales,
-            sourceLocale: config.sourceLocale,
-        });
-        if (!options.allowEmpty &&
-            locale !== config.pseudoLocale &&
-            missingMessages.length > 0) {
-            console.error(picocolors_1.default.red(`Error: Failed to compile catalog for locale ${picocolors_1.default.bold(locale)}!`));
-            if (options.verbose) {
-                console.error(picocolors_1.default.red("Missing translations:"));
-                missingMessages.forEach((missing) => {
-                    const source = missing.source || missing.source === missing.id
-                        ? `: (${missing.source})`
-                        : "";
-                    console.error(`${missing.id}${source}`);
-                });
+    if (!options.workersOptions.poolSize) {
+        // single threaded
+        const catalogs = await (0, api_1.getCatalogs)(config);
+        for (const locale of config.locales) {
+            try {
+                await (0, compileLocale_1.compileLocale)(catalogs, locale, options, config, doMerge, console);
             }
-            else {
-                console.error(picocolors_1.default.red(`Missing ${missingMessages.length} translation(s)`));
+            catch (err) {
+                if (err.name === "ProgramExit") {
+                    errored = true;
+                }
+                else {
+                    throw err;
+                }
             }
-            console.error();
-            throw new ProgramExit();
         }
-        if (doMerge) {
-            mergedCatalogs = Object.assign(Object.assign({}, mergedCatalogs), messages);
+    }
+    else {
+        if (!config.resolvedConfigPath) {
+            throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
         }
-        else {
-            if (!(await compileAndWrite(locale, config, options, catalog, messages))) {
-                throw new ProgramExit();
+        options.verbose &&
+            console.log(`Use worker pool of size ${options.workersOptions.poolSize}`);
+        const pool = (0, threads_1.Pool)(() => (0, threads_1.spawn)(new threads_1.Worker("./workers/compileWorker")), { size: options.workersOptions.poolSize });
+        try {
+            for (const locale of config.locales) {
+                pool.queue(async (worker) => {
+                    const { logs, error, exitProgram } = await worker.compileLocale(locale, options, doMerge, config.resolvedConfigPath);
+                    if (logs.errors) {
+                        console.error(logs.errors);
+                    }
+                    if (exitProgram) {
+                        errored = true;
+                        return;
+                    }
+                    if (error) {
+                        throw error;
+                    }
+                });
             }
+            await pool.completed(true);
         }
-    }));
-    if (doMerge) {
-        const result = await compileAndWrite(locale, config, options, await (0, getCatalogs_1.getCatalogForMerge)(config), mergedCatalogs);
-        if (!result) {
-            throw new ProgramExit();
+        finally {
+            await pool.terminate();
         }
     }
-}
-async function compileAndWrite(locale, config, options, catalogToWrite, messages) {
-    const namespace = options.typescript
-        ? "ts"
-        : options.namespace || config.compileNamespace;
-    const { source: compiledCatalog, errors } = (0, compile_1.createCompiledCatalog)(locale, messages, {
-        strict: false,
-        namespace,
-        pseudoLocale: config.pseudoLocale,
-        compilerBabelOptions: config.compilerBabelOptions,
-    });
-    if (errors.length) {
-        let message = (0, api_1.createCompilationErrorMessage)(locale, errors);
-        if (options.failOnCompileError) {
-            message += `These errors fail command execution because \`--strict\` option passed`;
-            console.error(picocolors_1.default.red(message));
-            return false;
-        }
-        else {
-            message += `You can fail command execution on these errors by passing \`--strict\` option`;
-            console.error(picocolors_1.default.red(message));
-        }
-    }
-    let compiledPath = await catalogToWrite.writeCompiled(locale, compiledCatalog, namespace);
-    compiledPath = (0, normalize_path_1.default)(path_1.default.relative(config.rootDir, compiledPath));
-    options.verbose && console.error(picocolors_1.default.green(`${locale} ⇒ ${compiledPath}`));
-    return true;
+    console.log(`Done in ${(0, ms_1.default)(Date.now() - startTime)}`);
+    return !errored;
 }
 if (require.main === module) {
     commander_1.program
-        .description("Add compile message catalogs and add language data (plurals) to compiled bundle.")
+        .description("Compile message catalogs to compiled bundle.")
         .option("--config <path>", "Path to the config file")
         .option("--strict", "Disable defaults for missing translations")
         .option("--verbose", "Verbose output")
         .option("--typescript", "Create Typescript definition for compiled bundle")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .option("--namespace <namespace>", "Specify namespace for compiled bundle. Ex: cjs(default) -> module.exports, es -> export, window.test -> window.test")
         .option("--watch", "Enables Watch Mode")
         .option("--debounce <delay>", "Debounces compilation for given amount of milliseconds")
@@ -135,6 +99,7 @@ if (require.main === module) {
             verbose: options.watch || options.verbose || false,
             allowEmpty: !options.strict,
             failOnCompileError: !!options.strict,
+            workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
             typescript: options.typescript || config.compileNamespace === "ts" || false,
             namespace: options.namespace, // we want this to be undefined if user does not specify so default can be used
         }));
@@ -180,7 +145,6 @@ if (require.main === module) {
             if (!results) {
                 process.exit(1);
             }
-            console.log("Done!");
         });
     }
 }

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

@@ -1,10 +1,12 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
+import { WorkersOptions } from "./api/resolveWorkersOptions";
 export type CliExtractTemplateOptions = {
-    verbose: boolean;
+    verbose?: boolean;
     files?: string[];
     template?: boolean;
     locales?: string[];
     overwrite?: boolean;
     clean?: boolean;
+    workersOptions: WorkersOptions;
 };
-export default function command(linguiConfig: LinguiConfigNormalized, options: Partial<CliExtractTemplateOptions>): Promise<boolean>;
+export default function command(linguiConfig: LinguiConfigNormalized, options: CliExtractTemplateOptions): Promise<boolean>;

package/dist/lingui-extract-experimental.js

@@ -10,13 +10,13 @@ const conf_1 = require("@lingui/conf");
 const path_1 = __importDefault(require("path"));
 const formats_1 = require("./api/formats");
 const promises_1 = __importDefault(require("fs/promises"));
-const extractFromFiles_1 = require("./api/catalog/extractFromFiles");
 const normalize_path_1 = __importDefault(require("normalize-path"));
 const bundleSource_1 = require("./extract-experimental/bundleSource");
-const writeCatalogs_1 = require("./extract-experimental/writeCatalogs");
 const getEntryPoints_1 = require("./extract-experimental/getEntryPoints");
 const picocolors_1 = __importDefault(require("picocolors"));
-const babel_1 = require("./api/extractors/babel");
+const threads_1 = require("threads");
+const resolveWorkersOptions_1 = require("./api/resolveWorkersOptions");
+const extractFromBundleAndWrite_1 = require("./extract-experimental/extractFromBundleAndWrite");
 async function command(linguiConfig, options) {
     var _a;
     options.verbose && console.log("Extracting messages from source files…");
@@ -43,58 +43,58 @@ async function command(linguiConfig, options) {
     const bundleResult = await (0, bundleSource_1.bundleSource)(linguiConfig, (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);
-    linguiConfig.extractors = [
-        {
-            match(_filename) {
-                return true;
-            },
-            async extract(filename, code, onMessageExtracted, ctx) {
-                const parserOptions = ctx.linguiConfig.extractorParserOptions;
-                return (0, babel_1.extractFromFileWithBabel)(filename, code, onMessageExtracted, ctx, {
-                    plugins: (0, babel_1.getBabelParserOptions)(filename, parserOptions),
-                }, true);
-            },
-        },
-    ];
-    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.workersOptions.poolSize) {
+        if (!linguiConfig.resolvedConfigPath) {
+            throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
         }
-        if (options.template) {
-            output = (await (0, writeCatalogs_1.writeTemplate)({
-                linguiConfig,
-                clean: options.clean,
-                format,
-                messages,
+        options.verbose &&
+            console.log(`Use worker pool of size ${options.workersOptions.poolSize}`);
+        const pool = (0, threads_1.Pool)(() => (0, threads_1.spawn)(new threads_1.Worker("./extract-experimental/workers/extractWorker")), { size: options.workersOptions.poolSize });
+        try {
+            for (const outFile of Object.keys(bundleResult.metafile.outputs)) {
+                const { entryPoint } = bundleResult.metafile.outputs[outFile];
+                pool.queue(async (extractFromBundleAndWrite) => {
+                    const { success, stat } = await extractFromBundleAndWrite(linguiConfig.resolvedConfigPath, entryPoint, outFile, config.output, options.template, options.locales || linguiConfig.locales, options.clean, options.overwrite);
+                    commandSuccess && (commandSuccess = success);
+                    stats.push({
+                        entry: (0, normalize_path_1.default)(path_1.default.relative(linguiConfig.rootDir, entryPoint)),
+                        content: stat,
+                    });
+                });
+            }
+            await pool.completed();
+        }
+        finally {
+            await pool.terminate();
+        }
+    }
+    else {
+        const format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+        for (const outFile of Object.keys(bundleResult.metafile.outputs)) {
+            const { entryPoint } = bundleResult.metafile.outputs[outFile];
+            const { success, stat } = await (0, extractFromBundleAndWrite_1.extractFromBundleAndWrite)({
                 entryPoint,
+                bundleFile: outFile,
                 outputPattern: config.output,
-            })).statMessage;
-        }
-        else {
-            output = (await (0, writeCatalogs_1.writeCatalogs)({
-                locales: options.locales || linguiConfig.locales,
-                linguiConfig,
-                clean: options.clean,
                 format,
-                messages,
-                entryPoint,
+                linguiConfig,
+                locales: options.locales || linguiConfig.locales,
                 overwrite: options.overwrite,
-                outputPattern: config.output,
-            })).statMessage;
+                clean: options.clean,
+                template: options.template,
+            });
+            commandSuccess && (commandSuccess = success);
+            stats.push({
+                entry: (0, normalize_path_1.default)(path_1.default.relative(linguiConfig.rootDir, entryPoint)),
+                content: stat,
+            });
         }
-        stats.push({
-            entry: (0, normalize_path_1.default)(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 }) => {
+    stats
+        .sort((a, b) => a.entry.localeCompare(b.entry))
+        .forEach(({ entry, content }) => {
         console.log([`Catalog statistics for ${entry}:`, content, ""].join("\n"));
     });
     return commandSuccess;
@@ -107,6 +107,7 @@ if (require.main === module) {
         .option("--clean", "Remove obsolete translations")
         .option("--locale <locale, [...]>", "Only extract the specified locales")
         .option("--verbose", "Verbose output")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .parse(process.argv);
     const options = commander_1.program.opts();
     const config = (0, conf_1.getConfig)({
@@ -118,6 +119,7 @@ if (require.main === module) {
         locales: (_a = options.locale) === null || _a === void 0 ? void 0 : _a.split(","),
         overwrite: options.overwrite,
         clean: options.clean,
+        workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
     }).then(() => {
         if (!result)
             process.exit(1);

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

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

package/dist/lingui-extract-template.js

@@ -10,18 +10,33 @@ const conf_1 = require("@lingui/conf");
 const api_1 = require("./api");
 const path_1 = __importDefault(require("path"));
 const normalize_path_1 = __importDefault(require("normalize-path"));
+const extractWorkerPool_1 = require("./api/extractWorkerPool");
+const resolveWorkersOptions_1 = require("./api/resolveWorkersOptions");
 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, normalize_path_1.default)(path_1.default.relative(config.rootDir, catalog.templateFile))] = Object.keys(result).length;
+    let workerPool;
+    if (options.workersOptions.poolSize) {
+        options.verbose &&
+            console.log(`Use worker pool of size ${options.workersOptions.poolSize}`);
+        workerPool = (0, extractWorkerPool_1.createExtractWorkerPool)(options.workersOptions);
+    }
+    try {
+        await Promise.all(catalogs.map(async (catalog) => {
+            const result = await catalog.makeTemplate(Object.assign(Object.assign({}, options), { orderBy: config.orderBy, workerPool }));
+            if (result) {
+                catalogStats[(0, normalize_path_1.default)(path_1.default.relative(config.rootDir, catalog.templateFile))] = Object.keys(result).length;
+            }
+            commandSuccess && (commandSuccess = Boolean(result));
+        }));
+    }
+    finally {
+        if (workerPool) {
+            await workerPool.terminate();
         }
-        commandSuccess && (commandSuccess = Boolean(result));
-    }));
+    }
     Object.entries(catalogStats).forEach(([key, value]) => {
         console.log(`Catalog statistics for ${picocolors_1.default.bold(key)}: ${picocolors_1.default.green(value)} messages`);
         console.log();
@@ -32,6 +47,7 @@ if (require.main === module) {
     commander_1.program
         .option("--config <path>", "Path to the config file")
         .option("--verbose", "Verbose output")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .parse(process.argv);
     const options = commander_1.program.opts();
     const config = (0, conf_1.getConfig)({
@@ -39,6 +55,7 @@ if (require.main === module) {
     });
     const result = command(config, {
         verbose: options.verbose || false,
+        workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
     }).then(() => {
         if (!result)
             process.exit(1);

package/dist/lingui-extract.d.ts

@@ -1,4 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
+import { WorkersOptions } from "./api/resolveWorkersOptions";
 export type CliExtractOptions = {
     verbose: boolean;
     files?: string[];
@@ -7,5 +8,6 @@ export type CliExtractOptions = {
     locale: string[];
     prevFormat: string | null;
     watch?: boolean;
+    workersOptions: WorkersOptions;
 };
 export default function command(config: LinguiConfigNormalized, options: Partial<CliExtractOptions>): Promise<boolean>;

package/dist/lingui-extract.js

@@ -14,22 +14,44 @@ const stats_1 = require("./api/stats");
 const help_1 = require("./api/help");
 const ora_1 = __importDefault(require("ora"));
 const normalize_path_1 = __importDefault(require("normalize-path"));
+const resolveWorkersOptions_1 = require("./api/resolveWorkersOptions");
+const extractWorkerPool_1 = require("./api/extractWorkerPool");
+const ms_1 = __importDefault(require("ms"));
 async function command(config, options) {
+    const startTime = Date.now();
     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();
-    await Promise.all(catalogs.map(async (catalog) => {
-        const result = await catalog.make(Object.assign(Object.assign({}, options), { orderBy: config.orderBy }));
-        catalogStats[(0, normalize_path_1.default)(path_1.default.relative(config.rootDir, catalog.path))] = result || {};
-        commandSuccess && (commandSuccess = Boolean(result));
-    }));
+    let workerPool;
+    // important to initialize ora before worker pool, otherwise it cause
+    // MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 unpipe listeners added to [WriteStream]. MaxListeners is 10. Use emitter.setMaxListeners() to increase limit
+    // when workers >= 10
+    const spinner = (0, ora_1.default)();
+    if (options.workersOptions.poolSize) {
+        options.verbose &&
+            console.log(`Use worker pool of size ${options.workersOptions.poolSize}`);
+        workerPool = (0, extractWorkerPool_1.createExtractWorkerPool)(options.workersOptions);
+    }
+    spinner.start();
+    try {
+        await Promise.all(catalogs.map(async (catalog) => {
+            const result = await catalog.make(Object.assign(Object.assign({}, options), { orderBy: config.orderBy, workerPool }));
+            catalogStats[(0, normalize_path_1.default)(path_1.default.relative(config.rootDir, catalog.path))] = result || {};
+            commandSuccess && (commandSuccess = Boolean(result));
+        }));
+    }
+    finally {
+        if (workerPool) {
+            await workerPool.terminate();
+        }
+    }
+    const doneMsg = `Done in ${(0, ms_1.default)(Date.now() - startTime)}`;
     if (commandSuccess) {
-        spinner.succeed();
+        spinner.succeed(doneMsg);
     }
     else {
-        spinner.fail();
+        spinner.fail(doneMsg);
     }
     Object.entries(catalogStats).forEach(([key, value]) => {
         console.log(`Catalog statistics for ${key}: `);
@@ -67,6 +89,7 @@ if (require.main === module) {
             .map((s) => s.trim())
             .filter(Boolean);
     })
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .option("--overwrite", "Overwrite translations for source locale")
         .option("--clean", "Remove obsolete translations")
         .option("--debounce <delay>", "Debounces extraction for given amount of milliseconds")
@@ -109,6 +132,7 @@ if (require.main === module) {
             watch: options.watch || false,
             files: (filePath === null || filePath === void 0 ? void 0 : filePath.length) ? filePath : undefined,
             prevFormat,
+            workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
         });
     };
     const changedPaths = new Set();

package/dist/workers/compileWorker.d.ts

@@ -0,0 +1,11 @@
+import { CliCompileOptions } from "../lingui-compile";
+import { SerializedLogs } from "../api/workerLogger";
+declare const compileWorker: {
+    compileLocale: (locale: string, options: CliCompileOptions, doMerge: boolean, linguiConfigPath: string) => Promise<{
+        logs?: SerializedLogs;
+        error?: unknown;
+        exitProgram?: boolean;
+    }>;
+};
+export type CompileWorker = typeof compileWorker;
+export {};