@lingui/cli 5.9.3 → 6.0.0-next.1

package/dist/lingui-compile.js

@@ -1,20 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = command;
-const picocolors_1 = __importDefault(require("picocolors"));
-const chokidar_1 = __importDefault(require("chokidar"));
-const commander_1 = require("commander");
-const conf_1 = require("@lingui/conf");
-const help_1 = require("./api/help");
-const api_1 = require("./api");
-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) {
+import { styleText } from "node:util";
+import chokidar from "chokidar";
+import { program } from "commander";
+import { getConfig } from "@lingui/conf";
+import { helpRun } from "./api/help.js";
+import { getCatalogs } from "./api/index.js";
+import { compileLocale } from "./api/compile/compileLocale.js";
+import { createCompileWorkerPool } from "./api/workerPools.js";
+import { resolveWorkersOptions, } from "./api/resolveWorkersOptions.js";
+import ms from "ms";
+import { getPathsForCompileWatcher } from "./api/getPathsForCompileWatcher.js";
+export async function command(config, options) {
     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;
@@ -22,10 +17,10 @@ async function command(config, options) {
     let errored = false;
     if (!options.workersOptions.poolSize) {
         // single threaded
-        const catalogs = await (0, api_1.getCatalogs)(config);
+        const catalogs = await getCatalogs(config);
         for (const locale of config.locales) {
             try {
-                await (0, compileLocale_1.compileLocale)(catalogs, locale, options, config, doMerge, console);
+                await compileLocale(catalogs, locale, options, config, doMerge, console);
             }
             catch (err) {
                 if (err.name === "ProgramExit") {
@@ -38,39 +33,39 @@ async function command(config, options) {
         }
     }
     else {
-        if (!config.resolvedConfigPath) {
+        const resolvedConfigPath = config.resolvedConfigPath;
+        if (!resolvedConfigPath) {
             throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
         }
         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 });
+        const pool = createCompileWorkerPool({
+            poolSize: 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);
+            await Promise.all(config.locales.map(async (locale) => {
+                const { logs, error, exitProgram } = await pool.run(locale, options, doMerge, resolvedConfigPath);
+                if (logs.errors) {
+                    console.error(logs.errors);
+                }
+                if (exitProgram) {
+                    errored = true;
+                    return;
+                }
+                if (error) {
+                    throw error;
+                }
+            }));
         }
         finally {
-            await pool.terminate(true);
+            await pool.destroy();
         }
     }
-    console.log(`Done in ${(0, ms_1.default)(Date.now() - startTime)}`);
+    console.log(`Done in ${ms(Date.now() - startTime)}`);
     return !errored;
 }
-if (require.main === module) {
-    commander_1.program
+if (import.meta.main) {
+    program
         .description("Compile message catalogs to compiled bundle.")
         .option("--config <path>", "Path to the config file")
         .option("--strict", "Disable defaults for missing translations")
@@ -84,23 +79,23 @@ if (require.main === module) {
         .on("--help", function () {
         console.log("\n  Examples:\n");
         console.log("    # Compile translations and use defaults or message IDs for missing translations");
-        console.log(`    $ ${(0, help_1.helpRun)("compile")}`);
+        console.log(`    $ ${helpRun("compile")}`);
         console.log("");
         console.log("    # Compile translations but fail when there are missing");
         console.log("    # translations (don't replace missing translations with");
         console.log("    # default messages or message IDs)");
-        console.log(`    $ ${(0, help_1.helpRun)("compile --strict")}`);
+        console.log(`    $ ${helpRun("compile --strict")}`);
     })
         .parse(process.argv);
-    const options = commander_1.program.opts();
-    const config = (0, conf_1.getConfig)({ configPath: options.config });
+    const options = program.opts();
+    const config = getConfig({ configPath: options.config });
     let previousRun = Promise.resolve(true);
     const compile = () => {
         previousRun = previousRun.then(() => command(config, {
             verbose: options.watch || options.verbose || false,
             allowEmpty: !options.strict,
             failOnCompileError: !!options.strict,
-            workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
+            workersOptions: 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
             outputPrefix: options.outputPrefix,
@@ -118,23 +113,14 @@ if (require.main === module) {
     };
     // Check if Watch Mode is enabled
     if (options.watch) {
-        console.info(picocolors_1.default.bold("Initializing Watch Mode..."));
+        console.info(styleText("bold", "Initializing Watch Mode..."));
         (async function initWatch() {
-            const format = await (0, api_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
-            const catalogs = await (0, api_1.getCatalogs)(config);
-            const paths = [];
-            config.locales.forEach((locale) => {
-                catalogs.forEach((catalog) => {
-                    paths.push(`${catalog.path
-                        .replace(/{locale}/g, locale)
-                        .replace(/{name}/g, "*")}${format.getCatalogExtension()}`);
-                });
-            });
-            const watcher = chokidar_1.default.watch(paths, {
+            const { paths } = await getPathsForCompileWatcher(config);
+            const watcher = chokidar.watch(paths, {
                 persistent: true,
             });
             const onReady = () => {
-                console.info(picocolors_1.default.green(picocolors_1.default.bold("Watcher is ready!")));
+                console.info(styleText(["green", "bold"], "Watcher is ready!"));
                 watcher
                     .on("add", () => dispatchCompile())
                     .on("change", () => dispatchCompile());

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

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

package/dist/lingui-extract-experimental.js

@@ -1,30 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = command;
-const commander_1 = require("commander");
-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 normalize_path_1 = __importDefault(require("normalize-path"));
-const bundleSource_1 = require("./extract-experimental/bundleSource");
-const getEntryPoints_1 = require("./extract-experimental/getEntryPoints");
-const picocolors_1 = __importDefault(require("picocolors"));
-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;
+import { program } from "commander";
+import { getConfig } from "@lingui/conf";
+import nodepath from "path";
+import { getFormat } from "./api/formats/index.js";
+import fs from "fs/promises";
+import normalizePath from "normalize-path";
+import { bundleSource } from "./extract-experimental/bundleSource.js";
+import { globSync } from "node:fs";
+import { styleText } from "node:util";
+import { resolveWorkersOptions, } from "./api/resolveWorkersOptions.js";
+import { extractFromBundleAndWrite } from "./extract-experimental/extractFromBundleAndWrite.js";
+import { createExtractExperimentalWorkerPool } from "./api/workerPools.js";
+export default async function command(linguiConfig, options) {
     options.verbose && console.log("Extracting messages from source files…");
-    const config = (_a = linguiConfig.experimental) === null || _a === void 0 ? void 0 : _a.extractor;
-    if (!config) {
+    const extractorConfig = linguiConfig.experimental?.extractor;
+    if (!extractorConfig) {
         throw new Error("The configuration for experimental extractor is empty. Please read the docs.");
     }
-    console.log(picocolors_1.default.yellow([
+    console.log(styleText("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.",
@@ -37,61 +29,65 @@ async function command(linguiConfig, options) {
     // sourcemaps itself doesn't allow to have absolute windows path, because they are not URL compatible.
     // that's why we store esbuild bundles in .lingui folder
     const tmpPrefix = ".lingui/";
-    await promises_1.default.mkdir(tmpPrefix, { recursive: true });
-    const tempDir = await promises_1.default.mkdtemp(tmpPrefix);
-    await promises_1.default.rm(tempDir, { recursive: true, force: true });
-    const bundleResult = await (0, bundleSource_1.bundleSource)(linguiConfig, (0, getEntryPoints_1.getEntryPoints)(config.entries), tempDir, linguiConfig.rootDir);
+    await fs.mkdir(tmpPrefix, { recursive: true });
+    const tempDir = await fs.mkdtemp(tmpPrefix);
+    await fs.rm(tempDir, { recursive: true, force: true });
+    const bundleResult = await bundleSource(linguiConfig, extractorConfig, globSync(extractorConfig.entries), tempDir, linguiConfig.rootDir);
     const stats = [];
     let commandSuccess = true;
     if (options.workersOptions.poolSize) {
-        if (!linguiConfig.resolvedConfigPath) {
+        const resolvedConfigPath = linguiConfig.resolvedConfigPath;
+        if (!resolvedConfigPath) {
             throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
         }
         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 });
+        const pool = createExtractExperimentalWorkerPool({
+            poolSize: 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);
+            await Promise.all(Object.keys(bundleResult.outputs).map(async (outFile) => {
+                const { entryPoint } = bundleResult.outputs[outFile];
+                const result = await pool.run(resolvedConfigPath, entryPoint, outFile, extractorConfig.output, options.template || false, options.locales || linguiConfig.locales, options.clean || false, options.overwrite || false);
+                commandSuccess &&= result.success;
+                if (result.success) {
                     stats.push({
-                        entry: (0, normalize_path_1.default)(path_1.default.relative(linguiConfig.rootDir, entryPoint)),
-                        content: stat,
+                        entry: normalizePath(nodepath.relative(linguiConfig.rootDir, entryPoint)),
+                        content: result.stat,
                     });
-                });
-            }
-            await pool.completed();
+                }
+            }));
         }
         finally {
-            await pool.terminate(true);
+            await pool.destroy();
         }
     }
     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,
+        const format = await getFormat(linguiConfig.format, linguiConfig.sourceLocale);
+        for (const outFile of Object.keys(bundleResult.outputs)) {
+            const { entryPoint } = bundleResult.outputs[outFile];
+            const result = await extractFromBundleAndWrite({
+                entryPoint: entryPoint,
                 bundleFile: outFile,
-                outputPattern: config.output,
+                outputPattern: extractorConfig.output,
                 format,
                 linguiConfig,
                 locales: options.locales || linguiConfig.locales,
-                overwrite: options.overwrite,
-                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,
+                overwrite: options.overwrite || false,
+                clean: options.clean || false,
+                template: options.template || false,
             });
+            commandSuccess &&= result.success;
+            if (result.success) {
+                stats.push({
+                    entry: normalizePath(nodepath.relative(linguiConfig.rootDir, entryPoint)),
+                    content: result.stat,
+                });
+            }
         }
     }
     // cleanup temp directory
-    await promises_1.default.rm(tempDir, { recursive: true, force: true });
+    await fs.rm(tempDir, { recursive: true, force: true });
     stats
         .sort((a, b) => a.entry.localeCompare(b.entry))
         .forEach(({ entry, content }) => {
@@ -99,8 +95,8 @@ async function command(linguiConfig, options) {
     });
     return commandSuccess;
 }
-if (require.main === module) {
-    commander_1.program
+if (import.meta.main) {
+    program
         .option("--config <path>", "Path to the config file")
         .option("--template", "Extract to template")
         .option("--overwrite", "Overwrite translations for source locale")
@@ -109,17 +105,17 @@ if (require.main === module) {
         .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)({
+    const options = program.opts();
+    const config = 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(","),
+        locales: options.locale?.split(","),
         overwrite: options.overwrite,
         clean: options.clean,
-        workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
+        workersOptions: resolveWorkersOptions(options),
     }).then(() => {
         if (!result)
             process.exit(1);

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

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

package/dist/lingui-extract-template.js

@@ -1,61 +1,59 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = command;
-const picocolors_1 = __importDefault(require("picocolors"));
-const commander_1 = require("commander");
-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) {
+import { styleText } from "node:util";
+import { program } from "commander";
+import { getConfig } from "@lingui/conf";
+import { getCatalogs } from "./api/index.js";
+import nodepath from "path";
+import normalizePath from "normalize-path";
+import { createExtractWorkerPool, } from "./api/workerPools.js";
+import { resolveWorkersOptions, } from "./api/resolveWorkersOptions.js";
+export default async function command(config, options) {
     options.verbose && console.log("Extracting messages from source files…");
-    const catalogs = await (0, api_1.getCatalogs)(config);
+    const catalogs = await getCatalogs(config);
     const catalogStats = {};
     let commandSuccess = true;
     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);
+        workerPool = 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 }));
+            const result = await catalog.makeTemplate({
+                ...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;
+                catalogStats[normalizePath(nodepath.relative(config.rootDir, catalog.templateFile))] = Object.keys(result).length;
             }
-            commandSuccess && (commandSuccess = Boolean(result));
+            commandSuccess &&= Boolean(result);
         }));
     }
     finally {
         if (workerPool) {
-            await workerPool.terminate(true);
+            await workerPool.destroy();
         }
     }
     Object.entries(catalogStats).forEach(([key, value]) => {
-        console.log(`Catalog statistics for ${picocolors_1.default.bold(key)}: ${picocolors_1.default.green(value)} messages`);
+        console.log(`Catalog statistics for ${styleText("bold", key)}: ${styleText("green", String(value))} messages`);
         console.log();
     });
     return commandSuccess;
 }
-if (require.main === module) {
-    commander_1.program
+if (import.meta.main) {
+    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)({
+    const options = program.opts();
+    const config = getConfig({
         configPath: options.config,
     });
     const result = command(config, {
         verbose: options.verbose || false,
-        workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
+        workersOptions: resolveWorkersOptions(options),
     }).then(() => {
         if (!result)
             process.exit(1);

package/dist/lingui-extract.d.ts

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