@lingui/cli 5.9.1 → 6.0.0-next.0

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

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];