@lingui/cli 5.9.3 → 6.0.0-next.1

package/dist/lingui-extract.js

@@ -1,54 +1,55 @@
-"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 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 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) {
+import { styleText } from "node:util";
+import chokidar from "chokidar";
+import { program } from "commander";
+import nodepath from "path";
+import { getConfig } from "@lingui/conf";
+import { getCatalogs } from "./api/index.js";
+import { printStats } from "./api/stats.js";
+import { helpRun } from "./api/help.js";
+import ora from "ora";
+import normalizePath from "normalize-path";
+import { resolveWorkersOptions, } from "./api/resolveWorkersOptions.js";
+import { createExtractWorkerPool, } from "./api/workerPools.js";
+import ms from "ms";
+import { getPathsForExtractWatcher } from "./api/getPathsForExtractWatcher.js";
+import { glob } from "node:fs/promises";
+import micromatch from "micromatch";
+export default 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 catalogs = await getCatalogs(config);
     const catalogStats = {};
     let commandSuccess = true;
     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)();
+    const spinner = ora();
     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);
     }
     spinner.start();
     let extractionResult;
     try {
         extractionResult = 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));
+            const result = await catalog.make({
+                ...options,
+                orderBy: config.orderBy,
+                workerPool,
+            });
+            catalogStats[normalizePath(nodepath.relative(config.rootDir, catalog.path))] = result || {};
+            commandSuccess &&= Boolean(result);
             return { catalog, messagesByLocale: result };
         }));
     }
     finally {
         if (workerPool) {
-            await workerPool.terminate(true);
+            await workerPool.destroy();
         }
     }
-    const doneMsg = `Done in ${(0, ms_1.default)(Date.now() - startTime)}`;
+    const doneMsg = `Done in ${ms(Date.now() - startTime)}`;
     if (commandSuccess) {
         spinner.succeed(doneMsg);
     }
@@ -57,20 +58,24 @@ async function command(config, options) {
     }
     Object.entries(catalogStats).forEach(([key, value]) => {
         console.log(`Catalog statistics for ${key}: `);
-        console.log((0, stats_1.printStats)(config, value).toString());
+        console.log(printStats(config, value).toString());
         console.log();
     });
     if (!options.watch) {
-        console.log(`(Use "${picocolors_1.default.yellow((0, help_1.helpRun)("extract"))}" to update catalogs with new messages.)`);
-        console.log(`(Use "${picocolors_1.default.yellow((0, help_1.helpRun)("compile"))}" to compile catalogs for production. Alternatively, use bundler plugins: https://lingui.dev/ref/cli#compiling-catalogs-in-ci)`);
+        console.log(`(Use "${styleText("yellow", helpRun("extract"))}" to update catalogs with new messages.)`);
+        console.log(`(Use "${styleText("yellow", helpRun("compile"))}" to compile catalogs for production. Alternatively, use bundler plugins: https://lingui.dev/ref/cli#compiling-catalogs-in-ci)`);
     }
     // If service key is present in configuration, synchronize with cloud translation platform
-    if (typeof config.service === "object" &&
-        config.service.name &&
-        config.service.name.length) {
+    if (config.service?.name?.length) {
         const moduleName = config.service.name.charAt(0).toLowerCase() + config.service.name.slice(1);
+        const services = {
+            translationIO: () => import(`./services/translationIO.js`),
+        };
+        if (!services[moduleName]) {
+            console.error(`Can't load service module ${moduleName}`);
+        }
         try {
-            const module = require(`./services/${moduleName}`);
+            const module = services[moduleName]();
             await module
                 .default(config, options, extractionResult)
                 .then(console.log)
@@ -82,8 +87,8 @@ async function command(config, options) {
     }
     return commandSuccess;
 }
-if (require.main === module) {
-    commander_1.program
+if (import.meta.main) {
+    program
         .option("--config <path>", "Path to the config file")
         .option("--locale <locale, [...]>", "Only extract the specified locales", (value) => {
         return value
@@ -96,30 +101,18 @@ if (require.main === module) {
         .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)({
+    const options = program.opts();
+    const config = 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 ${picocolors_1.default.bold("new")} format in LinguiJS configuration\n` +
-            ` and ${picocolors_1.default.bold("previous")} format using --convert-from option.`);
-        console.log();
-        console.log(`Example: Convert from lingui format to minimal`);
-        console.log(picocolors_1.default.yellow((0, help_1.helpRun)(`extract --convert-from lingui`)));
-        process.exit(1);
-    }
     if (options.locale) {
         const missingLocale = options.locale.find((l) => !config.locales.includes(l));
         if (missingLocale) {
             hasErrors = true;
-            console.error(`Locale ${picocolors_1.default.bold(missingLocale)} does not exist.`);
+            console.error(`Locale ${styleText("bold", missingLocale)} does not exist.`);
             console.error();
         }
     }
@@ -132,9 +125,8 @@ if (require.main === module) {
             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,
-            workersOptions: (0, resolveWorkersOptions_1.resolveWorkersOptions)(options),
+            files: filePath?.length ? filePath : undefined,
+            workersOptions: resolveWorkersOptions(options),
         });
     };
     const changedPaths = new Set();
@@ -147,7 +139,7 @@ if (require.main === module) {
             previousExtract = previousExtract.then(() => extract(filePath));
             return previousExtract;
         }
-        filePath === null || filePath === void 0 ? void 0 : filePath.forEach((path) => changedPaths.add(path));
+        filePath?.forEach((path) => changedPaths.add(path));
         // CLear the previous timer if there is any, and schedule the next
         debounceTimer && clearTimeout(debounceTimer);
         debounceTimer = setTimeout(async () => {
@@ -158,21 +150,22 @@ 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 catalogs = await (0, api_1.getCatalogs)(config);
-            const paths = [];
-            const ignored = [];
-            catalogs.forEach((catalog) => {
-                paths.push(...catalog.include);
-                ignored.push(...catalog.exclude);
-            });
-            const watcher = chokidar_1.default.watch(paths, {
-                ignored: ["/(^|[/\\])../", ...ignored],
+            const { paths, ignored } = await getPathsForExtractWatcher(config);
+            const matchedPaths = [];
+            for await (const path of glob(paths)) {
+                matchedPaths.push(path);
+            }
+            const watcher = chokidar.watch(matchedPaths, {
+                ignored: [
+                    "/(^|[/\\])../",
+                    (path) => micromatch.any(path, ignored),
+                ],
                 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", (path) => dispatchExtract([path]))
                     .on("change", (path) => dispatchExtract([path]));
@@ -180,10 +173,10 @@ if (require.main === module) {
             watcher.on("ready", () => onReady());
         })();
     }
-    else if (commander_1.program.args) {
+    else if (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) => {
+        extract(program.args).then((result) => {
             if (!result)
                 process.exit(1);
         });

package/dist/lingui.js

@@ -1,14 +1,9 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.resolve(__dirname, "../package.json"), "utf8"));
-commander_1.program
+import { program } from "commander";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+const packageJson = JSON.parse(readFileSync(path.resolve(import.meta.dirname, "../package.json"), "utf8"));
+program
     .version(packageJson.version)
     .command("extract [files...]", "Extracts messages from source files")
     .command("extract-experimental", "Extracts messages from source files traversing dependency tree")

package/dist/services/translationIO/segment-converters.d.ts

@@ -1,4 +1,4 @@
 import { MessageType } from "@lingui/conf";
-import { TranslationIoSegment } from "./translationio-api";
+import { TranslationIoSegment } from "./translationio-api.js";
 export declare function createSegmentFromLinguiItem(key: string, item: MessageType): TranslationIoSegment;
 export declare function createLinguiItemFromSegment(segment: TranslationIoSegment): readonly [string, MessageType];

package/dist/services/translationIO/segment-converters.js

@@ -1,21 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSegmentFromLinguiItem = createSegmentFromLinguiItem;
-exports.createLinguiItemFromSegment = createLinguiItemFromSegment;
-const generateMessageId_1 = require("@lingui/message-utils/generateMessageId");
+import { generateMessageId } from "@lingui/message-utils/generateMessageId";
 const EXPLICIT_ID_FLAG = "js-lingui-explicit-id";
 const EXPLICIT_ID_AND_CONTEXT_FLAG = "js-lingui-explicit-id-and-context";
 function isGeneratedId(id, message) {
-    return id === (0, generateMessageId_1.generateMessageId)(message.message, message.context);
+    return id === generateMessageId(message.message, message.context);
 }
 const joinOrigin = (origin) => origin.join(":");
 const splitOrigin = (origin) => {
     const [file, line] = origin.split(":");
     return [file, line ? Number(line) : null];
 };
-function createSegmentFromLinguiItem(key, item) {
+export function createSegmentFromLinguiItem(key, item) {
     const itemHasExplicitId = !isGeneratedId(key, item);
-    const itemHasContext = !!item.context;
     const segment = {
         type: "source", // No way to edit text for source language (inside code), so not using "key" here
         source: "",
@@ -25,12 +20,12 @@ function createSegmentFromLinguiItem(key, item) {
     };
     // For segment.source & segment.context, we must remain compatible with projects created/synced before Lingui V4
     if (itemHasExplicitId) {
-        segment.source = item.message || item.translation;
+        segment.source = item.message || item.translation || "";
         segment.context = key;
     }
     else {
-        segment.source = item.message || item.translation;
-        if (itemHasContext) {
+        segment.source = item.message || item.translation || "";
+        if (item.context) {
             segment.context = item.context;
         }
     }
@@ -40,7 +35,7 @@ function createSegmentFromLinguiItem(key, item) {
     // Since Lingui v4, when using explicit IDs, Lingui automatically adds 'js-lingui-explicit-id' to the extractedComments array
     const comments = [];
     if (itemHasExplicitId) {
-        if (itemHasContext) {
+        if (item.context) {
             // segment.context is already used for the explicit ID, so we need to pass the context (for translators) in segment.comment
             comments.push(item.context, EXPLICIT_ID_AND_CONTEXT_FLAG);
         }
@@ -51,30 +46,31 @@ function createSegmentFromLinguiItem(key, item) {
     segment.comment = [...comments, ...(item.comments || [])].join(" | ");
     return segment;
 }
-function createLinguiItemFromSegment(segment) {
-    var _a, _b, _c;
-    const segmentHasExplicitId = (_a = segment.comment) === null || _a === void 0 ? void 0 : _a.includes(EXPLICIT_ID_FLAG);
-    const segmentHasExplicitIdAndContext = (_b = segment.comment) === null || _b === void 0 ? void 0 : _b.includes(EXPLICIT_ID_AND_CONTEXT_FLAG);
+export function createLinguiItemFromSegment(segment) {
+    const segmentHasExplicitId = segment.comment?.includes(EXPLICIT_ID_FLAG);
+    const segmentHasExplicitIdAndContext = segment.comment?.includes(EXPLICIT_ID_AND_CONTEXT_FLAG);
     const item = {
         translation: segment.target,
-        origin: ((_c = segment.references) === null || _c === void 0 ? void 0 : _c.length)
+        origin: segment.references?.length
             ? segment.references.map(splitOrigin)
             : [],
         message: segment.source,
         comments: [],
+        placeholders: {},
     };
-    let id = null;
+    let id;
     if (segmentHasExplicitId || segmentHasExplicitIdAndContext) {
         id = segment.context;
     }
     else {
-        id = (0, generateMessageId_1.generateMessageId)(segment.source, segment.context);
+        id = generateMessageId(segment.source, segment.context);
         item.context = segment.context;
     }
     if (segment.comment) {
         item.comments = segment.comment.split(" | ").filter(
         // drop flags from comments
-        (comment) => comment !== EXPLICIT_ID_AND_CONTEXT_FLAG && comment !== EXPLICIT_ID_FLAG);
+        (comment) => comment !== EXPLICIT_ID_AND_CONTEXT_FLAG &&
+            comment !== EXPLICIT_ID_FLAG);
         // We recompose a target PO Item that is consistent with the source PO Item
         if (segmentHasExplicitIdAndContext) {
             item.context = item.comments.shift();

package/dist/services/translationIO/translationio-api.d.ts

@@ -27,13 +27,6 @@ export type TranslationIoProject = {
     name: string;
     url: string;
 };
-export type TranslationIoResponse = {
-    errors?: string[];
-    project?: TranslationIoProject;
-    segments?: {
-        [locale: string]: TranslationIoSegment[];
-    };
-};
 export type FetchResult<T> = {
     data: T;
     error: undefined;
@@ -44,5 +37,16 @@ export type FetchResult<T> = {
     };
     data: undefined;
 };
+export type TranslationIoResponse = TranslationIoErrorResponse | TranslationProjectResponse;
+type TranslationIoErrorResponse = {
+    errors: string[];
+};
+type TranslationProjectResponse = {
+    project: TranslationIoProject;
+    segments: {
+        [locale: string]: TranslationIoSegment[];
+    };
+};
 export declare function tioSync(request: TranslationIoSyncRequest, apiKey: string): Promise<FetchResult<TranslationIoResponse>>;
 export declare function tioInit(request: TranslationIoInitRequest, apiKey: string): Promise<FetchResult<TranslationIoResponse>>;
+export {};

package/dist/services/translationIO/translationio-api.js

@@ -1,20 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tioSync = tioSync;
-exports.tioInit = tioInit;
-// todo: need to enable strictNullChecks to support this kind of type narrowing
-// export type TranslationIoResponse =
-//   | TranslationIoErrorResponse
-//   | TranslationProjectResponse
-//
-// type TranslationIoErrorResponse = {
-//   errors: string[]
-// }
-// type TranslationProjectResponse = {
-//   errors: null
-//   project: TranslationIoProject
-//   segments: { [locale: string]: TranslationIoSegment[] }
-// }
 async function post(url, request) {
     const response = await fetch(url, {
         method: "POST",
@@ -34,9 +17,9 @@ async function post(url, request) {
     }
     return { data: await response.json(), error: undefined };
 }
-async function tioSync(request, apiKey) {
+export async function tioSync(request, apiKey) {
     return post(`https://translation.io/api/v1/segments/sync.json?api_key=${apiKey}`, request);
 }
-async function tioInit(request, apiKey) {
+export async function tioInit(request, apiKey) {
     return post(`https://translation.io/api/v1/segments/init.json?api_key=${apiKey}`, request);
 }

package/dist/services/translationIO.d.ts

@@ -1,8 +1,8 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { CliExtractOptions } from "../lingui-extract";
-import { TranslationIoProject, TranslationIoSegment } from "./translationIO/translationio-api";
-import { Catalog } from "../api/catalog";
-import { AllCatalogsType } from "../api/types";
+import { CliExtractOptions } from "../lingui-extract.js";
+import { TranslationIoProject, TranslationIoSegment } from "./translationIO/translationio-api.js";
+import { Catalog } from "../api/catalog.js";
+import { AllCatalogsType } from "../api/types.js";
 type ExtractionResult = {
     catalog: Catalog;
     messagesByLocale: AllCatalogsType;

package/dist/services/translationIO.js

@@ -1,24 +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.default = syncProcess;
-exports.init = init;
-exports.sync = sync;
-exports.writeSegmentsToCatalogs = writeSegmentsToCatalogs;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const translationio_api_1 = require("./translationIO/translationio-api");
-const catalog_1 = require("../api/catalog");
-const segment_converters_1 = require("./translationIO/segment-converters");
+import fs from "fs";
+import { dirname } from "path";
+import { tioInit, tioSync, } from "./translationIO/translationio-api.js";
+import { order } from "../api/catalog.js";
+import { createLinguiItemFromSegment, createSegmentFromLinguiItem, } from "./translationIO/segment-converters.js";
 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
-async function syncProcess(config, options, extractionResult) {
+export default async function syncProcess(config, options, extractionResult) {
     const reportSuccess = (project) => {
         return `\n----------\nProject successfully synchronized. Please use this URL to translate: ${project.url}\n----------`;
     };
@@ -40,7 +31,7 @@ async function syncProcess(config, options, extractionResult) {
 }
 // Initialize project with source and existing translations (only first time!)
 // Cf. https://translation.io/docs/create-library#initialization
-async function init(config, extractionResult) {
+export async function init(config, extractionResult) {
     const sourceLocale = config.sourceLocale || "en";
     const targetLocales = getTargetLocales(config);
     const segments = {};
@@ -54,7 +45,7 @@ async function init(config, extractionResult) {
             if (entry.obsolete)
                 return;
             targetLocales.forEach((targetLocale) => {
-                segments[targetLocale].push((0, segment_converters_1.createSegmentFromLinguiItem)(key, entry));
+                segments[targetLocale].push(createSegmentFromLinguiItem(key, entry));
             });
         });
     }
@@ -69,7 +60,7 @@ async function init(config, extractionResult) {
             });
         }
     }
-    const { data, error } = await (0, translationio_api_1.tioInit)({
+    const { data, error } = await tioInit({
         client: "lingui",
         version: require("@lingui/core/package.json").version,
         source_language: sourceLocale,
@@ -79,7 +70,7 @@ async function init(config, extractionResult) {
     if (error) {
         return { success: false, errors: [error.message] };
     }
-    if (data.errors) {
+    if ("errors" in data) {
         return { success: false, errors: data.errors };
     }
     await writeSegmentsToCatalogs(config, sourceLocale, extractionResult, data.segments);
@@ -87,7 +78,7 @@ async function init(config, extractionResult) {
 }
 // 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
-async function sync(config, options, extractionResult) {
+export async function sync(config, options, extractionResult) {
     const sourceLocale = config.sourceLocale || "en";
     const targetLocales = getTargetLocales(config);
     const segments = [];
@@ -97,10 +88,10 @@ async function sync(config, options, extractionResult) {
         Object.entries(messages).forEach(([key, entry]) => {
             if (entry.obsolete)
                 return;
-            segments.push((0, segment_converters_1.createSegmentFromLinguiItem)(key, entry));
+            segments.push(createSegmentFromLinguiItem(key, entry));
         });
     }
-    const { data, error } = await (0, translationio_api_1.tioSync)({
+    const { data, error } = await tioSync({
         client: "lingui",
         version: require("@lingui/core/package.json").version,
         source_language: sourceLocale,
@@ -112,13 +103,13 @@ async function sync(config, options, extractionResult) {
     if (error) {
         return { success: false, errors: [error.message] };
     }
-    if (data.errors) {
+    if ("errors" in data) {
         return { success: false, errors: data.errors };
     }
     await writeSegmentsToCatalogs(config, sourceLocale, extractionResult, data.segments);
     return { success: true, project: data.project };
 }
-async function writeSegmentsToCatalogs(config, sourceLocale, extractionResult, segmentsPerLocale) {
+export async function writeSegmentsToCatalogs(config, sourceLocale, extractionResult, segmentsPerLocale) {
     // Create segments from source locale PO items
     for (const { catalog, messagesByLocale } of extractionResult) {
         const sourceMessages = messagesByLocale[sourceLocale];
@@ -127,28 +118,30 @@ async function writeSegmentsToCatalogs(config, sourceLocale, extractionResult, s
             {
                 const path = catalog.getFilename(targetLocale);
                 const jsPath = path.replace(new RegExp(`${catalog.format.getCatalogExtension()}$`), "") + ".js";
-                const dirPath = (0, path_1.dirname)(path);
+                const dirPath = dirname(path);
                 // todo: check tests and all these logic, maybe it could be simplified to just drop the folder
                 // Remove PO, JS and empty dir
-                if (fs_1.default.existsSync(path)) {
-                    await fs_1.default.promises.unlink(path);
+                if (fs.existsSync(path)) {
+                    await fs.promises.unlink(path);
                 }
-                if (fs_1.default.existsSync(jsPath)) {
-                    await fs_1.default.promises.unlink(jsPath);
+                if (fs.existsSync(jsPath)) {
+                    await fs.promises.unlink(jsPath);
                 }
-                if (fs_1.default.existsSync(dirPath) && fs_1.default.readdirSync(dirPath).length === 0) {
-                    await fs_1.default.promises.rmdir(dirPath);
+                if (fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0) {
+                    await fs.promises.rmdir(dirPath);
                 }
             }
-            const translations = Object.fromEntries(segmentsPerLocale[targetLocale].map((segment) => (0, segment_converters_1.createLinguiItemFromSegment)(segment)));
+            const translations = Object.fromEntries(segmentsPerLocale[targetLocale].map((segment) => createLinguiItemFromSegment(segment)));
             const messages = Object.fromEntries(Object.entries(sourceMessages).map(([key, entry]) => {
-                var _a;
                 return [
                     key,
-                    Object.assign(Object.assign({}, entry), { translation: (_a = translations[key]) === null || _a === void 0 ? void 0 : _a.translation }),
+                    {
+                        ...entry,
+                        translation: translations[key]?.translation,
+                    },
                 ];
             }));
-            await catalog.write(targetLocale, (0, catalog_1.order)(config.orderBy, messages));
+            await catalog.write(targetLocale, order(config.orderBy, messages));
         }
     }
 }

package/dist/workers/compileWorker.d.ts

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