@lingui/cli 5.9.2 → 6.0.0-next.0

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

@@ -1,2 +1,3 @@
-import { LinguiConfigNormalized } from "@lingui/conf";
-export declare function bundleSource(linguiConfig: LinguiConfigNormalized, entryPoints: string[], outDir: string, rootDir: string): Promise<import("esbuild").BuildResult<any>>;
+import { ExperimentalExtractorOptions, LinguiConfigNormalized } from "@lingui/conf";
+import { Metafile } from "esbuild";
+export declare function bundleSource(linguiConfig: LinguiConfigNormalized, extractorConfig: ExperimentalExtractorOptions, entryPoints: string[], outDir: string, rootDir: string): Promise<Metafile>;

package/dist/extract-experimental/bundleSource.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundleSource = bundleSource;
-const linguiEsbuildPlugin_1 = require("./linguiEsbuildPlugin");
-const buildIncludeDepsFilter_1 = require("./buildIncludeDepsFilter");
+import { pluginLinguiMacro } from "./linguiEsbuildPlugin.js";
+import { buildIncludeDepsFilter } from "./buildIncludeDepsFilter.js";
 function createExtRegExp(extensions) {
     return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
 }
-async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
+export async function bundleSource(linguiConfig, extractorConfig, entryPoints, outDir, rootDir) {
     const esbuild = await import("esbuild");
-    const config = linguiConfig.experimental.extractor;
-    const excludeExtensions = config.excludeExtensions || [
+    const excludeExtensions = extractorConfig.excludeExtensions || [
         "ico",
         "pot",
         "xliff",
@@ -44,16 +40,16 @@ async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
         sourcesContent: false,
         metafile: true,
         plugins: [
-            (0, linguiEsbuildPlugin_1.pluginLinguiMacro)({ linguiConfig }),
+            pluginLinguiMacro({ linguiConfig }),
             {
                 name: "externalize-deps",
                 setup(build) {
-                    const shouldInclude = (0, buildIncludeDepsFilter_1.buildIncludeDepsFilter)(config.includeDeps || []);
+                    const shouldInclude = buildIncludeDepsFilter(extractorConfig.includeDeps || []);
                     // considers all import paths that "look like" package imports in the original source code to be package imports.
                     // Specifically import paths that don't start with a path segment of / or . or .. are considered to be package imports.
                     // The only two exceptions to this rule are subpath imports (which start with a # character) and deps specified in the `includeDeps`
                     build.onResolve({ filter: /^[^.#/].*/ }, async (args) => {
-                        if (shouldInclude(args.path)) {
+                        if (shouldInclude(args.path) || args.kind === "entry-point") {
                             return { external: false };
                         }
                         return {
@@ -72,7 +68,8 @@ async function bundleSource(linguiConfig, entryPoints, outDir, rootDir) {
             },
         ],
     };
-    return await esbuild.build(config.resolveEsbuildOptions
-        ? config.resolveEsbuildOptions(esbuildOptions)
+    const bundleResult = await esbuild.build(extractorConfig.resolveEsbuildOptions
+        ? extractorConfig.resolveEsbuildOptions(esbuildOptions)
         : esbuildOptions);
+    return bundleResult.metafile;
 }

package/dist/extract-experimental/constants.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TEMPLATE_NAME = exports.ENTRY_NAME_PH = void 0;
-exports.ENTRY_NAME_PH = "{entryName}";
-exports.DEFAULT_TEMPLATE_NAME = "messages";
+export const ENTRY_NAME_PH = "{entryName}";
+export const DEFAULT_TEMPLATE_NAME = "messages";

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

@@ -1,5 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { FormatterWrapper } from "../api/formats";
+import { FormatterWrapper } from "../api/formats/index.js";
 export declare function extractFromBundleAndWrite(params: {
     entryPoint: string;
     bundleFile: string;
@@ -11,9 +11,8 @@ export declare function extractFromBundleAndWrite(params: {
     clean: boolean;
     overwrite: boolean;
 }): Promise<{
-    success: boolean;
-    stat?: undefined;
+    success: false;
 } | {
-    success: boolean;
+    success: true;
     stat: string;
 }>;

package/dist/extract-experimental/extractFromBundleAndWrite.js

@@ -1,25 +1,19 @@
-"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");
+import { mergeExtractedMessage } from "../api/catalog/extractFromFiles.js";
+import { writeCatalogs, writeTemplate } from "./writeCatalogs.js";
+import fs from "fs/promises";
+import { extractFromFileWithBabel, getBabelParserOptions, } from "../api/extractors/babel.js";
 async function extractFromBundle(filename, linguiConfig) {
     const messages = {};
     let success;
     try {
-        const file = await promises_1.default.readFile(filename);
+        const file = await fs.readFile(filename);
         const parserOptions = linguiConfig.extractorParserOptions;
-        await (0, babel_1.extractFromFileWithBabel)(filename, file.toString(), (msg) => {
-            (0, extractFromFiles_1.mergeExtractedMessage)(msg, messages, linguiConfig);
+        await extractFromFileWithBabel(filename, file.toString(), (msg) => {
+            mergeExtractedMessage(msg, messages, linguiConfig);
         }, {
             linguiConfig,
         }, {
-            plugins: (0, babel_1.getBabelParserOptions)(filename, parserOptions),
+            plugins: getBabelParserOptions(filename, parserOptions),
         }, true);
         success = true;
     }
@@ -30,7 +24,7 @@ async function extractFromBundle(filename, linguiConfig) {
     }
     return { success, messages };
 }
-async function extractFromBundleAndWrite(params) {
+export 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) {
@@ -38,7 +32,7 @@ async function extractFromBundleAndWrite(params) {
     }
     let stat;
     if (template) {
-        stat = (await (0, writeCatalogs_1.writeTemplate)({
+        stat = (await writeTemplate({
             linguiConfig,
             clean,
             format,
@@ -48,7 +42,7 @@ async function extractFromBundleAndWrite(params) {
         })).statMessage;
     }
     else {
-        stat = (await (0, writeCatalogs_1.writeCatalogs)({
+        stat = (await writeCatalogs({
             locales,
             linguiConfig,
             clean,

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

@@ -1,3 +1,4 @@
-import { LinguiConfigNormalized } from "@lingui/conf";
-import { Catalog } from "../api/catalog";
-export declare function getExperimentalCatalogs(linguiConfig: LinguiConfigNormalized): Promise<Catalog[]>;
+import { ExperimentalExtractorOptions, LinguiConfigNormalized } from "@lingui/conf";
+import { Catalog } from "../api/catalog.js";
+import { FormatterWrapper } from "../api/formats/index.js";
+export declare function getExperimentalCatalogs(linguiConfig: LinguiConfigNormalized, format: FormatterWrapper, extractorConfig: ExperimentalExtractorOptions): Promise<Catalog[]>;

package/dist/extract-experimental/getExperimentalCatalogs.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExperimentalCatalogs = getExperimentalCatalogs;
-const getEntryPoints_1 = require("./getEntryPoints");
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const catalog_1 = require("../api/catalog");
-const resolveTemplatePath_1 = require("./resolveTemplatePath");
-const formats_1 = require("../api/formats");
-async function getExperimentalCatalogs(linguiConfig) {
-    const config = linguiConfig.experimental.extractor;
-    const entryPoints = (0, getEntryPoints_1.getEntryPoints)(config.entries);
-    const format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+import { globSync } from "node:fs";
+import { resolveCatalogPath } from "./resolveCatalogPath.js";
+import { Catalog } from "../api/catalog.js";
+import { resolveTemplatePath } from "./resolveTemplatePath.js";
+export async function getExperimentalCatalogs(linguiConfig, format, extractorConfig) {
+    const config = extractorConfig;
+    const entryPoints = globSync(config.entries);
     return entryPoints.map((entryPoint) => {
-        const catalogPath = (0, resolveCatalogPath_1.resolveCatalogPath)(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
-        const templatePath = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
-        return new catalog_1.Catalog({
+        const catalogPath = resolveCatalogPath(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
+        const templatePath = resolveTemplatePath(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
+        return new Catalog({
             name: undefined,
             path: catalogPath,
             templatePath,

package/dist/extract-experimental/linguiEsbuildPlugin.js

@@ -1,36 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginLinguiMacro = void 0;
-const core_1 = require("@babel/core");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const babel_1 = require("../api/extractors/babel");
-const babel_plugin_lingui_macro_1 = __importDefault(require("@lingui/babel-plugin-lingui-macro"));
-const pluginLinguiMacro = (options) => ({
+import { transformAsync } from "@babel/core";
+import fs from "fs";
+import path from "path";
+import { babelRe, getBabelParserOptions } from "../api/extractors/babel.js";
+import linguiMacroPlugin from "@lingui/babel-plugin-lingui-macro";
+export const pluginLinguiMacro = (options) => ({
     name: "linguiMacro",
     setup(build) {
-        build.onLoad({ filter: babel_1.babelRe, namespace: "" }, async (args) => {
-            const filename = path_1.default.relative(process.cwd(), args.path);
-            const contents = await fs_1.default.promises.readFile(args.path, "utf8");
+        build.onLoad({ filter: babelRe, namespace: "" }, async (args) => {
+            const filename = path.relative(process.cwd(), args.path);
+            const contents = await fs.promises.readFile(args.path, "utf8");
             const hasMacroRe = /from ["']@lingui(\/.+)?\/macro["']/g;
             if (!hasMacroRe.test(contents)) {
                 // let esbuild process file as usual
                 return undefined;
             }
-            const result = await (0, core_1.transformAsync)(contents, {
+            const result = await transformAsync(contents, {
                 babelrc: false,
                 configFile: false,
                 filename: filename,
                 sourceMaps: "inline",
                 parserOpts: {
-                    plugins: (0, babel_1.getBabelParserOptions)(filename, options.linguiConfig.extractorParserOptions),
+                    plugins: getBabelParserOptions(filename, options.linguiConfig.extractorParserOptions),
                 },
                 plugins: [
                     [
-                        babel_plugin_lingui_macro_1.default,
+                        linguiMacroPlugin,
                         {
                             extract: true,
                             linguiConfig: options.linguiConfig,
@@ -42,4 +36,3 @@ const pluginLinguiMacro = (options) => ({
         });
     },
 });
-exports.pluginLinguiMacro = pluginLinguiMacro;

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

@@ -1,2 +1,2 @@
-export declare function resolveCatalogPath(configOutput: string, entryPath: string, rootDir: string, locale: string, extension: string): string;
+export declare function resolveCatalogPath(configOutput: string, entryPath: string, rootDir: string, locale: string | undefined, extension: string): string;
 export declare function getEntryName(entryPath: string): string;

package/dist/extract-experimental/resolveCatalogPath.js

@@ -1,22 +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.resolveCatalogPath = resolveCatalogPath;
-exports.getEntryName = getEntryName;
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("../api/utils");
-function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
+import nodepath from "path";
+import { replacePlaceholders } from "../api/utils.js";
+export function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
     const entryName = getEntryName(entryPath);
-    const entryDir = path_1.default.relative(rootDir, path_1.default.dirname(entryPath));
-    return path_1.default.normalize((0, utils_1.replacePlaceholders)(configOutput, {
+    const entryDir = nodepath.relative(rootDir, nodepath.dirname(entryPath));
+    return nodepath.normalize(replacePlaceholders(configOutput, {
         entryName,
         entryDir,
         locale,
     }) + extension);
 }
-function getEntryName(entryPath) {
-    const parsedPath = path_1.default.parse(entryPath);
+export function getEntryName(entryPath) {
+    const parsedPath = nodepath.parse(entryPath);
     return parsedPath.name.replace(parsedPath.ext, "");
 }

package/dist/extract-experimental/resolveTemplatePath.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTemplatePath = resolveTemplatePath;
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const constants_1 = require("./constants");
-function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
+import { resolveCatalogPath, getEntryName } from "./resolveCatalogPath.js";
+import { DEFAULT_TEMPLATE_NAME, ENTRY_NAME_PH } from "./constants.js";
+export function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
     let templateName;
-    if (output.includes(constants_1.ENTRY_NAME_PH)) {
-        templateName = constants_1.DEFAULT_TEMPLATE_NAME;
+    if (output.includes(ENTRY_NAME_PH)) {
+        templateName = DEFAULT_TEMPLATE_NAME;
     }
     else {
-        templateName = (0, resolveCatalogPath_1.getEntryName)(entryPoint);
+        templateName = getEntryName(entryPoint);
     }
-    return (0, resolveCatalogPath_1.resolveCatalogPath)(output, entryPoint, rootDir, templateName, catalogExtension);
+    return resolveCatalogPath(output, entryPoint, rootDir, templateName, catalogExtension);
 }

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

@@ -1,6 +1,8 @@
 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;
+    success: false;
+} | {
+    success: true;
+    stat: string;
 }>;
-export {};
+export { extractWorker };

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

@@ -1,23 +1,20 @@
-"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");
+import { getConfig } from "@lingui/conf";
+import { extractFromBundleAndWrite } from "../extractFromBundleAndWrite.js";
+import { getFormat } from "../../api/formats/index.js";
 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)({
+        linguiConfig = getConfig({
             configPath: linguiConfigPath,
             skipValidation: true,
         });
     }
     if (!format) {
-        format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+        format = await getFormat(linguiConfig.format, linguiConfig.sourceLocale);
     }
-    return await (0, extractFromBundleAndWrite_1.extractFromBundleAndWrite)({
+    return await extractFromBundleAndWrite({
         entryPoint,
         bundleFile,
         outputPattern,
@@ -29,4 +26,4 @@ const extractWorker = async (linguiConfigPath, entryPoint, bundleFile, outputPat
         template,
     });
 };
-(0, worker_1.expose)(extractWorker);
+export { extractWorker };

package/dist/extract-experimental/workers/extractWorkerWrapper.prod.d.ts

@@ -0,0 +1,8 @@
+import { extractWorker } from "./extractWorker.js";
+declare const _default: (args: Parameters<typeof extractWorker>) => Promise<{
+    success: false;
+} | {
+    success: true;
+    stat: string;
+}>;
+export default _default;

package/dist/extract-experimental/workers/extractWorkerWrapper.prod.js

@@ -0,0 +1,2 @@
+import { extractWorker } from "./extractWorker.js";
+export default (args) => extractWorker(...args);

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

@@ -1,6 +1,6 @@
-import { ExtractedCatalogType } from "../api";
+import { ExtractedCatalogType } from "../api/index.js";
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { FormatterWrapper } from "../api/formats";
+import { FormatterWrapper } from "../api/formats/index.js";
 type ExtractTemplateParams = {
     format: FormatterWrapper;
     clean: boolean;

package/dist/extract-experimental/writeCatalogs.js

@@ -1,40 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeCatalogs = writeCatalogs;
-exports.writeTemplate = writeTemplate;
-const resolveTemplatePath_1 = require("./resolveTemplatePath");
-const picocolors_1 = __importDefault(require("picocolors"));
-const resolveCatalogPath_1 = require("./resolveCatalogPath");
-const mergeCatalog_1 = require("../api/catalog/mergeCatalog");
-const stats_1 = require("../api/stats");
-const catalog_1 = require("../api/catalog");
+import { resolveTemplatePath } from "./resolveTemplatePath.js";
+import { styleText } from "node:util";
+import { resolveCatalogPath } from "./resolveCatalogPath.js";
+import { mergeCatalog } from "../api/catalog/mergeCatalog.js";
+import { printStats } from "../api/stats.js";
+import { cleanObsolete, order } from "../api/catalog.js";
 function cleanAndSort(catalog, clean, orderBy) {
     if (clean) {
-        catalog = (0, catalog_1.cleanObsolete)(catalog);
+        catalog = cleanObsolete(catalog);
     }
-    return (0, catalog_1.order)(orderBy, catalog);
+    return order(orderBy, catalog);
 }
-async function writeCatalogs(params) {
+export async function writeCatalogs(params) {
     const { entryPoint, outputPattern, linguiConfig, locales, overwrite, format, clean, messages, } = params;
     const stat = {};
     for (const locale of locales) {
-        const catalogOutput = (0, resolveCatalogPath_1.resolveCatalogPath)(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
-        const catalog = (0, mergeCatalog_1.mergeCatalog)(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, { overwrite });
+        const catalogOutput = resolveCatalogPath(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
+        const catalog = mergeCatalog(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, { overwrite });
         await format.write(catalogOutput, cleanAndSort(catalog, clean, linguiConfig.orderBy), locale);
         stat[locale] = catalog;
     }
     return {
-        statMessage: (0, stats_1.printStats)(linguiConfig, stat).toString(),
+        statMessage: printStats(linguiConfig, stat).toString(),
     };
 }
-async function writeTemplate(params) {
+export async function writeTemplate(params) {
     const { entryPoint, outputPattern, linguiConfig, format, clean, messages } = params;
-    const catalogOutput = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
+    const catalogOutput = resolveTemplatePath(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
     await format.write(catalogOutput, cleanAndSort(messages, clean, linguiConfig.orderBy), undefined);
     return {
-        statMessage: `${picocolors_1.default.bold(Object.keys(messages).length)} message(s) extracted`,
+        statMessage: `${styleText("bold", String(Object.keys(messages).length))} message(s) extracted`,
     };
 }

package/dist/index.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = void 0;
-var conf_1 = require("@lingui/conf");
-Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return conf_1.defineConfig; } });
+export { defineConfig } from "@lingui/conf";

package/dist/lingui-compile.d.ts

@@ -1,5 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { WorkersOptions } from "./api/resolveWorkersOptions";
+import { WorkersOptions } from "./api/resolveWorkersOptions.js";
 export type CliCompileOptions = {
     verbose?: boolean;
     allowEmpty?: boolean;

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());