@lingui/cli 6.4.0 → 6.6.0

package/dist/api/catalog/getCatalogs.js

@@ -43,13 +43,18 @@ export async function getCatalogs(config) {
         });
         candidates.forEach((catalogDir) => {
             const name = path.basename(catalogDir);
+            const globName = escapeCatalogNameForGlob(name);
             catalogs.push(new Catalog({
                 name,
                 path: normalizeRelativePath(replacePlaceholders(catalog.path, { name })),
                 include: include.map((path) => replacePlaceholders(path, { name })),
                 exclude: exclude.map((path) => replacePlaceholders(path, { name })),
                 format,
-            }, config));
+            }, config, {
+                path: replacePlaceholders(catalog.path, { name: globName }),
+                include: include.map((path) => replacePlaceholders(path, { name: globName })),
+                exclude: exclude.map((path) => replacePlaceholders(path, { name: globName })),
+            }));
         });
     });
     if (config.experimental?.extractor &&
@@ -58,6 +63,9 @@ export async function getCatalogs(config) {
     }
     return catalogs;
 }
+function escapeCatalogNameForGlob(value) {
+    return value.replace(/[[\]()]/g, "[$&]");
+}
 /**
  * Ensure that value is always array. If not, turn it into an array of one element.
  */

package/dist/api/catalog.d.ts

@@ -29,7 +29,13 @@ export type CatalogProps = {
     templatePath?: string;
     format: FormatterWrapper;
 };
+type CatalogGlobPatterns = {
+    path: string;
+    include: Array<string>;
+    exclude: Array<string>;
+};
 export declare class Catalog {
+    #private;
     config: LinguiConfigNormalized;
     name?: string;
     path: string;
@@ -37,7 +43,7 @@ export declare class Catalog {
     exclude: Array<string>;
     format: FormatterWrapper;
     templateFile: string;
-    constructor({ name, path, include, templatePath, format, exclude }: CatalogProps, config: LinguiConfigNormalized);
+    constructor({ name, path, include, templatePath, format, exclude }: CatalogProps, config: LinguiConfigNormalized, globPatterns?: CatalogGlobPatterns);
     getFilename(locale: string): string;
     make(options: MakeOptions): Promise<AllCatalogsType | false>;
     makeTemplate(options: MakeTemplateOptions): Promise<CatalogType | false>;
@@ -71,3 +77,4 @@ export declare function cleanObsolete<T extends CatalogType>(messages: T): T;
 export declare function order<T extends CatalogType>(by: OrderBy, catalog: T): T;
 export declare function writeCompiled(path: string, locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
 export declare const orderByMessage: OrderByFn;
+export {};

package/dist/api/catalog.js

@@ -17,12 +17,19 @@ export class Catalog {
     exclude;
     format;
     templateFile;
-    constructor({ name, path, include, templatePath, format, exclude = [] }, config) {
+    #includePatterns;
+    #excludePatterns;
+    constructor({ name, path, include, templatePath, format, exclude = [] }, config, globPatterns = { path, include, exclude }) {
         this.config = config;
         this.name = name;
         this.path = normalizeRelativePath(path);
         this.include = include.map(normalizeRelativePath);
         this.exclude = [this.localeDir, ...exclude.map(normalizeRelativePath)];
+        this.#includePatterns = createCatalogPatterns(this.include, globPatterns.include.map(normalizeRelativePath));
+        this.#excludePatterns = createCatalogPatterns(this.exclude, [
+            getLocaleDir(normalizeRelativePath(globPatterns.path)),
+            ...globPatterns.exclude.map(normalizeRelativePath),
+        ]);
         this.format = format;
         this.templateFile =
             templatePath ||
@@ -194,30 +201,54 @@ export class Catalog {
     async readTemplate() {
         return await this.format.read(this.templateFile, undefined);
     }
+    /** @internal */
+    get sourcePatterns() {
+        return {
+            include: resolveCatalogPatterns(this.include, this.#includePatterns),
+            exclude: resolveCatalogPatterns(this.exclude, this.#excludePatterns),
+        };
+    }
     get sourcePaths() {
-        const includeGlobs = this.include.map((includePath) => {
+        const sourcePatterns = this.sourcePatterns;
+        const includeGlobs = this.include.map((includePath, index) => {
+            const includeGlob = sourcePatterns.include[index];
             const isDir = isDirectory(includePath);
             /**
              * glob library results from absolute patterns such as /foo/* are mounted onto the root setting using path.join.
              * On windows, this will by default result in /foo/* matching C:\foo\bar.txt.
              */
             return isDir
-                ? normalize(path.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*"))
-                : includePath;
+                ? normalize(path.resolve(process.cwd(), includePath === "/" ? "" : includeGlob, "**/*.*"))
+                : includeGlob;
         });
-        return globSync(includeGlobs, { exclude: this.exclude });
+        return globSync(includeGlobs, { exclude: sourcePatterns.exclude });
     }
     get localeDir() {
-        const localePatternIndex = this.path.indexOf(LOCALE);
-        if (localePatternIndex === -1) {
-            throw Error(`Invalid catalog path: ${LOCALE} variable is missing`);
-        }
-        return this.path.substring(0, localePatternIndex);
+        return getLocaleDir(this.path);
     }
     get locales() {
         return this.config.locales;
     }
 }
+function createCatalogPatterns(values, globs) {
+    return values.map((value, index) => ({
+        value,
+        glob: globs[index] ?? value,
+    }));
+}
+function resolveCatalogPatterns(values, patterns) {
+    return values.map((value, index) => {
+        const pattern = patterns[index];
+        return pattern?.value === value ? pattern.glob : value;
+    });
+}
+function getLocaleDir(catalogPath) {
+    const localePatternIndex = catalogPath.indexOf(LOCALE);
+    if (localePatternIndex === -1) {
+        throw Error(`Invalid catalog path: ${LOCALE} variable is missing`);
+    }
+    return catalogPath.substring(0, localePatternIndex);
+}
 function getTemplatePath(ext, path) {
     return path.replace(LOCALE_SUFFIX_RE, "messages" + ext);
 }

package/dist/api/compile/compileLocale.js

@@ -15,7 +15,7 @@ export async function compileLocale(catalogs, locale, options, config, doMerge,
             sourceLocale: config.sourceLocale,
         });
         if (!options.allowEmpty &&
-            locale !== config.pseudoLocale &&
+            locale !== config.pseudoLocale.locale &&
             missingMessages.length > 0) {
             logger.error(styleText("red", `Error: Failed to compile catalog for locale ${styleText("bold", locale)}!`));
             if (options.verbose) {
@@ -57,7 +57,8 @@ async function compileAndWrite(locale, config, options, writePath, messages, log
         strict: false,
         namespace,
         outputPrefix: options.outputPrefix,
-        pseudoLocale: config.pseudoLocale,
+        pseudoLocale: config.pseudoLocale.locale,
+        pseudoLocaleOptions: config.pseudoLocale.options,
         compilerBabelOptions: config.compilerBabelOptions,
     });
     if (errors.length) {

package/dist/api/compile.d.ts

@@ -1,5 +1,6 @@
 import { GeneratorOptions } from "@babel/generator";
 import { CompiledMessage } from "@lingui/message-utils/compileMessage";
+import type { PseudoLocaleOptions } from "@lingui/conf";
 export type CompiledCatalogNamespace = "cjs" | "es" | "ts" | "json" | string;
 type CompiledCatalogType = {
     [msgId: string]: string;
@@ -8,6 +9,7 @@ export type CreateCompileCatalogOptions = {
     strict?: boolean;
     namespace?: CompiledCatalogNamespace;
     pseudoLocale?: string;
+    pseudoLocaleOptions?: PseudoLocaleOptions;
     compilerBabelOptions?: GeneratorOptions;
     outputPrefix?: string;
 };
@@ -33,5 +35,5 @@ export declare function createCompiledCatalog(locale: string, messages: Compiled
  * Compile string message into AST tree. Message format is parsed/compiled into
  * JS arrays, which are handled in client.
  */
-export declare function compile(message: string, shouldPseudolocalize?: boolean): CompiledMessage;
+export declare function compile(message: string, shouldPseudolocalize?: boolean, pseudoLocaleOptions?: PseudoLocaleOptions): CompiledMessage;
 export {};

package/dist/api/compile.js

@@ -3,7 +3,7 @@ import { generate } from "@babel/generator";
 import { compileMessageOrThrow, } from "@lingui/message-utils/compileMessage";
 import pseudoLocalize from "./pseudoLocalize.js";
 export function createCompiledCatalog(locale, messages, options) {
-    const { strict = false, namespace = "cjs", pseudoLocale, compilerBabelOptions = {}, outputPrefix = "/*eslint-disable*/", } = options;
+    const { strict = false, namespace = "cjs", pseudoLocale, pseudoLocaleOptions, compilerBabelOptions = {}, outputPrefix = "/*eslint-disable*/", } = options;
     const shouldPseudolocalize = locale === pseudoLocale;
     const errors = [];
     const compiledMessages = Object.keys(messages)
@@ -12,7 +12,7 @@ export function createCompiledCatalog(locale, messages, options) {
         // Don't use `key` as a fallback translation in strict mode.
         const translation = (messages[key] || (!strict ? key : ""));
         try {
-            obj[key] = compile(translation, shouldPseudolocalize);
+            obj[key] = compile(translation, shouldPseudolocalize, pseudoLocaleOptions);
         }
         catch (e) {
             errors.push({
@@ -80,6 +80,6 @@ function buildExportStatement(expression, namespace) {
  * Compile string message into AST tree. Message format is parsed/compiled into
  * JS arrays, which are handled in client.
  */
-export function compile(message, shouldPseudolocalize = false) {
-    return compileMessageOrThrow(message, (value) => shouldPseudolocalize ? pseudoLocalize(value) : value);
+export function compile(message, shouldPseudolocalize = false, pseudoLocaleOptions) {
+    return compileMessageOrThrow(message, (value) => shouldPseudolocalize ? pseudoLocalize(value, pseudoLocaleOptions) : value);
 }

package/dist/api/getPathsForExtractWatcher.js

@@ -7,8 +7,9 @@ export async function getPathsForExtractWatcher(config) {
     const paths = [];
     const ignored = [];
     catalogs.forEach((catalog) => {
-        paths.push(...catalog.include);
-        ignored.push(...catalog.exclude);
+        const sourcePatterns = catalog.sourcePatterns;
+        paths.push(...sourcePatterns.include);
+        ignored.push(...sourcePatterns.exclude);
     });
     return { paths, ignored };
 }

package/dist/api/pseudoLocalize.d.ts

@@ -1 +1,2 @@
-export default function (message: string): string;
+import type { PseudoLocaleOptions } from "@lingui/conf";
+export default function (message: string, options?: PseudoLocaleOptions): string;

package/dist/api/pseudoLocalize.js

@@ -37,14 +37,15 @@ function addDelimitersVariables(message) {
 function removeDelimiters(message) {
     return message.replace(new RegExp(delimiter, "g"), "");
 }
-export default function (message) {
+export default function (message, options = {}) {
     message = addDelimitersHTMLTags(message);
     message = addDelimitersMacro(message);
     message = addDelimitersVariables(message);
     message = pseudolocale(message, {
-        delimiter,
         prepend: "",
         append: "",
+        ...options,
+        delimiter,
     });
     return removeDelimiters(message);
 }

package/dist/api/stats.js

@@ -25,7 +25,7 @@ export function printStats(config, catalogs) {
         return a.localeCompare(b);
     })
         .forEach((locale) => {
-        if (locale === config.pseudoLocale)
+        if (locale === config.pseudoLocale.locale)
             return; // skip pseudo locale
         const catalog = catalogs[locale];
         // catalog is null if no catalog exists on disk and the locale

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

@@ -0,0 +1,10 @@
+import type { BundleChunk } from "@lingui/conf";
+/**
+ * Traverse the chunk import graph to determine which entry points depend on each chunk.
+ * This lets us extract messages from shared/common chunks once and attribute them to all
+ * consuming entry catalogs.
+ */
+export declare function buildChunkGraph(rawChunks: BundleChunk[]): Array<{
+    filePath: string;
+    entryPoints: string[];
+}>;

package/dist/extract-experimental/buildChunkGraph.js

@@ -0,0 +1,37 @@
+/**
+ * Traverse the chunk import graph to determine which entry points depend on each chunk.
+ * This lets us extract messages from shared/common chunks once and attribute them to all
+ * consuming entry catalogs.
+ */
+export function buildChunkGraph(rawChunks) {
+    const chunkById = new Map(rawChunks.map((c) => [c.id, c]));
+    const chunkToEntries = new Map();
+    for (const chunk of rawChunks) {
+        if (!chunk.entryPoint)
+            continue;
+        const queue = [chunk.id];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const currentId = queue.pop();
+            if (visited.has(currentId))
+                continue;
+            visited.add(currentId);
+            if (!chunkToEntries.has(currentId)) {
+                chunkToEntries.set(currentId, new Set());
+            }
+            chunkToEntries.get(currentId).add(chunk.entryPoint);
+            const current = chunkById.get(currentId);
+            if (current) {
+                for (const imp of current.imports) {
+                    if (chunkById.has(imp)) {
+                        queue.push(imp);
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(chunkToEntries.entries()).map(([id, entries]) => ({
+        filePath: chunkById.get(id).filePath,
+        entryPoints: Array.from(entries),
+    }));
+}

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

@@ -0,0 +1,2 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+export declare const buildContentFilterRe: (config: LinguiConfigNormalized) => RegExp;

package/dist/extract-experimental/buildContentFilter.js

@@ -0,0 +1,12 @@
+export const buildContentFilterRe = (config) => {
+    const macroIds = new Set([
+        ...config.macro.corePackage,
+        ...config.macro.jsxPackage,
+    ]);
+    // 1. Escape any special regex characters in the IDs (just in case)
+    // 2. Join them with the '|' (OR) operator
+    const macroPattern = Array.from(macroIds)
+        .map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("|");
+    return new RegExp(`from ['"](?:${macroPattern})['"]`);
+};

package/dist/extract-experimental/bundlers/esbuild.d.ts

@@ -0,0 +1,29 @@
+import type { BuildOptions } from "esbuild";
+import type { ExperimentalExtractorBundler } from "@lingui/conf";
+export type EsbuildBundlerOptions = {
+    /**
+     * List of package name patterns to include for extraction.
+     *
+     * For example, to include all packages from your monorepo:
+     *
+     * ["@mycompany"]
+     *
+     * By default, all imports that look like package imports are ignored.
+     * This means imports that do not start with `/`, `./`, `../`, or `#`
+     * (used for subpath imports). TypeScript path aliases are also ignored
+     * because they look like package imports.
+     *
+     * Add here the packages you want to include.
+     */
+    includeDeps?: string[];
+    /**
+     * svg, jpg and other files which might be imported in application should be excluded from analysis.
+     * By default, extractor provides a comprehensive list of extensions. If you feel like something
+     * is missing in this list please fill an issue on GitHub
+     *
+     * NOTE: changing this param will override default list of extensions.
+     */
+    excludeExtensions?: string[];
+    resolveEsbuildOptions?: (options: BuildOptions) => BuildOptions;
+};
+export declare function createEsbuildBundler(options?: EsbuildBundlerOptions): ExperimentalExtractorBundler;

package/dist/extract-experimental/bundlers/esbuild.js

@@ -0,0 +1,134 @@
+import path from "path";
+import { buildIncludeDepsFilter } from "../buildIncludeDepsFilter.js";
+import { DEFAULT_EXCLUDE_EXTENSIONS } from "../constants.js";
+import { transformAsync } from "@babel/core";
+import fs from "fs";
+import { babelRe, getBabelParserOptions } from "../../api/extractors/babel.js";
+import linguiMacroPlugin from "@lingui/babel-plugin-lingui-macro";
+import { buildContentFilterRe } from "../buildContentFilter.js";
+function createExtRegExp(extensions) {
+    return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
+}
+// esbuild metafile reports entryPoint as cwd-relative with forward slashes.
+// Resolve to absolute and filter to only user-specified entries
+// (dynamic imports also get entryPoint set in metafile).
+function resolveIfUserEntry(metaEntryPoint, entryPointSet) {
+    const resolved = path.resolve(metaEntryPoint);
+    return entryPointSet.has(resolved) ? resolved : undefined;
+}
+export function createEsbuildBundler(options) {
+    return {
+        async bundle(entryPoints, outDir, linguiConfig) {
+            let esbuild;
+            try {
+                esbuild = await import("esbuild");
+            }
+            catch {
+                throw new Error(`"esbuild" is required for createEsbuildBundler but is not installed. ` +
+                    `Install it with: npm install esbuild`);
+            }
+            const includeDeps = options?.includeDeps || [];
+            const excludeExtensions = options?.excludeExtensions || DEFAULT_EXCLUDE_EXTENSIONS;
+            const shouldInclude = buildIncludeDepsFilter(includeDeps);
+            let esbuildOptions = {
+                entryPoints,
+                outExtension: { ".js": ".jsx" },
+                jsx: "preserve",
+                bundle: true,
+                platform: "node",
+                target: ["esnext"],
+                format: "esm",
+                splitting: true,
+                treeShaking: true,
+                outdir: outDir,
+                sourcemap: "inline",
+                sourceRoot: outDir,
+                sourcesContent: false,
+                metafile: true,
+                plugins: [
+                    pluginLinguiMacro({ linguiConfig }),
+                    {
+                        name: "externalize-deps",
+                        setup(build) {
+                            build.onResolve({ filter: /^[^.#/].*/ }, async (args) => {
+                                if (shouldInclude(args.path) || args.kind === "entry-point") {
+                                    return { external: false };
+                                }
+                                return { external: true };
+                            });
+                        },
+                    },
+                    {
+                        name: "externalize-files",
+                        setup(build) {
+                            build.onResolve({ filter: createExtRegExp(excludeExtensions) }, () => ({
+                                external: true,
+                            }));
+                            // for some dynamic imports, for example
+                            // await import(`../locales/${locale}.po`)
+                            // esbuild skips resolve, because files crawled from the disk
+                            // to exclude those files from build, load an empty object instead
+                            build.onLoad({ filter: createExtRegExp(excludeExtensions) }, () => {
+                                return {
+                                    contents: JSON.stringify({}),
+                                    loader: "json",
+                                };
+                            });
+                        },
+                    },
+                ],
+            };
+            if (options?.resolveEsbuildOptions) {
+                esbuildOptions = options.resolveEsbuildOptions(esbuildOptions);
+            }
+            const bundleResult = await esbuild.build(esbuildOptions);
+            const metafile = bundleResult.metafile;
+            const entryPointSet = new Set(entryPoints.map((ep) => path.resolve(ep)));
+            const allOutputPaths = new Set(Object.keys(metafile.outputs));
+            const chunks = Object.entries(metafile.outputs).map(([outputPath, meta]) => ({
+                id: outputPath,
+                filePath: outputPath,
+                entryPoint: meta.entryPoint
+                    ? resolveIfUserEntry(meta.entryPoint, entryPointSet)
+                    : undefined,
+                imports: meta.imports
+                    .filter((imp) => allOutputPaths.has(imp.path))
+                    .map((imp) => imp.path),
+            }));
+            return { chunks };
+        },
+    };
+}
+const pluginLinguiMacro = (options) => ({
+    name: "linguiMacro",
+    setup(build) {
+        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 = buildContentFilterRe(options.linguiConfig);
+            if (!hasMacroRe.test(contents)) {
+                // let esbuild process file as usual
+                return undefined;
+            }
+            const result = await transformAsync(contents, {
+                babelrc: false,
+                configFile: false,
+                filename,
+                sourceMaps: "inline",
+                parserOpts: {
+                    plugins: getBabelParserOptions(filename, {}),
+                },
+                plugins: [
+                    [
+                        linguiMacroPlugin,
+                        {
+                            descriptorFields: "all",
+                            linguiConfig: options.linguiConfig,
+                        },
+                    ],
+                ],
+            });
+            return { contents: result.code, loader: "tsx" };
+        });
+    },
+});

package/dist/extract-experimental/bundlers/rolldown.d.ts

@@ -0,0 +1,29 @@
+import type { BuildOptions } from "rolldown";
+import type { ExperimentalExtractorBundler } from "@lingui/conf";
+export type RolldownBundlerOptions = {
+    /**
+     * List of package name patterns to include for extraction.
+     *
+     * For example, to include all packages from your monorepo:
+     *
+     * ["@mycompany"]
+     *
+     * By default, all imports that look like package imports are ignored.
+     * This means imports that do not start with `/`, `./`, `../`, or `#`
+     * (used for subpath imports). TypeScript path aliases are also ignored
+     * because they look like package imports.
+     *
+     * Add here the packages you want to include.
+     */
+    includeDeps?: string[];
+    /**
+     * svg, jpg and other files which might be imported in application should be excluded from analysis.
+     * By default, extractor provides a comprehensive list of extensions. If you feel like something
+     * is missing in this list please fill an issue on GitHub
+     *
+     * NOTE: changing this param will override default list of extensions.
+     */
+    excludeExtensions?: string[];
+    resolveRolldownOptions?: (options: BuildOptions) => BuildOptions;
+};
+export declare function createRolldownBundler(options?: RolldownBundlerOptions): ExperimentalExtractorBundler;

package/dist/extract-experimental/bundlers/rolldown.js

@@ -0,0 +1,103 @@
+import path from "path";
+import { buildIncludeDepsFilter } from "../buildIncludeDepsFilter.js";
+import { DEFAULT_EXCLUDE_EXTENSIONS } from "../constants.js";
+import { buildContentFilterRe } from "../buildContentFilter.js";
+import linguiMacroPlugin from "@lingui/babel-plugin-lingui-macro";
+import { transformAsync } from "@babel/core";
+import { getBabelParserOptions } from "../../api/extractors/babel.js";
+function createExtRegExp(extensions) {
+    return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
+}
+export function createRolldownBundler(options) {
+    return {
+        async bundle(entryPoints, outDir, linguiConfig) {
+            let rolldown;
+            try {
+                rolldown = await import("rolldown");
+            }
+            catch {
+                throw new Error(`"rolldown" is required for createRolldownBundler but is not installed. ` +
+                    `Install it with: npm install rolldown`);
+            }
+            const includeDeps = options?.includeDeps || [];
+            const excludeExtensions = options?.excludeExtensions || DEFAULT_EXCLUDE_EXTENSIONS;
+            const shouldInclude = buildIncludeDepsFilter(includeDeps);
+            const extRegExp = createExtRegExp(excludeExtensions);
+            const hasMacroRe = buildContentFilterRe(linguiConfig);
+            const macroPlugin = {
+                name: "lingui:macro-transform",
+                transform: {
+                    filter: {
+                        id: /\.(?:[jt]sx?|[cm][jt]s)(?:$|\?)/,
+                        code: hasMacroRe,
+                    },
+                    handler: async (code, filename, meta) => {
+                        const result = await transformAsync(code, {
+                            babelrc: false,
+                            configFile: false,
+                            filename,
+                            sourceMaps: true,
+                            parserOpts: {
+                                plugins: getBabelParserOptions(filename, {}),
+                            },
+                            plugins: [
+                                [
+                                    linguiMacroPlugin,
+                                    {
+                                        descriptorFields: "all",
+                                        linguiConfig,
+                                    },
+                                ],
+                            ],
+                        });
+                        return { code: result?.code ?? undefined, map: result?.map };
+                    },
+                },
+            };
+            let rolldownOptions = {
+                input: entryPoints,
+                output: {
+                    dir: outDir,
+                    format: "esm",
+                    sourcemap: "inline",
+                    entryFileNames: "[name].jsx",
+                    sourcemapPathTransform: (relativeSourcePath, sourcemapPath) => {
+                        const sourcemapDir = path.dirname(sourcemapPath);
+                        const absoluteSource = path.resolve(sourcemapDir, relativeSourcePath);
+                        return path.relative(process.cwd(), absoluteSource);
+                    },
+                },
+                platform: "node",
+                treeshake: true,
+                transform: {
+                    jsx: "preserve",
+                },
+                external: (id, importer) => {
+                    if (extRegExp.test(id)) {
+                        return true;
+                    }
+                    if (importer && !path.isAbsolute(id) && /^[^.#/]/.test(id)) {
+                        return !shouldInclude(id);
+                    }
+                    return false;
+                },
+                plugins: [macroPlugin],
+            };
+            if (options?.resolveRolldownOptions) {
+                rolldownOptions = options.resolveRolldownOptions(rolldownOptions);
+            }
+            const result = await rolldown.build(rolldownOptions);
+            const outputChunks = result.output.filter((item) => item.type === "chunk");
+            const outputFileNames = new Set(outputChunks.map((c) => c.fileName));
+            const chunks = outputChunks.map((chunk) => ({
+                id: chunk.fileName,
+                filePath: path.join(outDir, chunk.fileName),
+                entryPoint: chunk.isEntry && chunk.facadeModuleId
+                    ? chunk.facadeModuleId.replace(/\\/g, "/")
+                    : undefined,
+                imports: [...chunk.imports, ...chunk.dynamicImports].filter((imp) => outputFileNames.has(imp)),
+            }));
+            return { chunks };
+        },
+    };
+}

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

@@ -1,2 +1,3 @@
 export declare const ENTRY_NAME_PH = "{entryName}";
 export declare const DEFAULT_TEMPLATE_NAME = "messages";
+export declare const DEFAULT_EXCLUDE_EXTENSIONS: string[];

package/dist/extract-experimental/constants.js

@@ -1,2 +1,23 @@
 export const ENTRY_NAME_PH = "{entryName}";
 export const DEFAULT_TEMPLATE_NAME = "messages";
+export const DEFAULT_EXCLUDE_EXTENSIONS = [
+    "ico",
+    "pot",
+    "po",
+    "webp",
+    "xliff",
+    "woff2",
+    "woff",
+    "eot",
+    "gif",
+    "otf",
+    "ttf",
+    "mp4",
+    "svg",
+    "png",
+    "css",
+    "sass",
+    "scss",
+    "less",
+    "jpg",
+];

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

@@ -0,0 +1,5 @@
+import { ExtractedMessage, LinguiConfigNormalized } from "@lingui/conf";
+export declare function extractFromChunk(filename: string, linguiConfig: LinguiConfigNormalized): Promise<{
+    success: boolean;
+    messages: ExtractedMessage[];
+}>;

package/dist/extract-experimental/extractFromChunk.js

@@ -0,0 +1,8 @@
+import extract from "../api/extractors/index.js";
+export async function extractFromChunk(filename, linguiConfig) {
+    const messages = [];
+    const success = await extract(filename, (msg) => {
+        messages.push(msg);
+    }, linguiConfig);
+    return { success, messages };
+}

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

@@ -1,8 +1,7 @@
+import { ExtractedMessage } from "@lingui/conf";
 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: false;
-} | {
-    success: true;
-    stat: string;
+declare const extractWorker: (linguiConfigPath: string, bundleFile: string) => Promise<{
+    success: boolean;
+    messages: ExtractedMessage[];
 }>;
 export { extractWorker };

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

@@ -1,29 +1,13 @@
-import { getConfig } from "@lingui/conf";
-import { extractFromBundleAndWrite } from "../extractFromBundleAndWrite.js";
-import { getFormat } from "../../api/formats/index.js";
+import { getConfig, } from "@lingui/conf";
+import { extractFromChunk } from "../extractFromChunk.js";
 let linguiConfig;
-let format;
-const extractWorker = async (linguiConfigPath, entryPoint, bundleFile, outputPattern, template, locales, clean, overwrite) => {
+const extractWorker = async (linguiConfigPath, bundleFile) => {
     if (!linguiConfig) {
-        // initialize config once per worker, speed up workers follow execution
         linguiConfig = getConfig({
             configPath: linguiConfigPath,
             skipValidation: true,
         });
     }
-    if (!format) {
-        format = await getFormat(linguiConfig.format, linguiConfig.sourceLocale);
-    }
-    return await extractFromBundleAndWrite({
-        entryPoint,
-        bundleFile,
-        outputPattern,
-        format,
-        linguiConfig,
-        locales,
-        overwrite,
-        clean,
-        template,
-    });
+    return await extractFromChunk(bundleFile, linguiConfig);
 };
 export { extractWorker };

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

@@ -1,8 +1,6 @@
 import { extractWorker } from "./extractWorker.js";
 declare const _default: (args: Parameters<typeof extractWorker>) => Promise<{
-    success: false;
-} | {
-    success: true;
-    stat: string;
+    success: boolean;
+    messages: import("packages/conf/dist/index.mjs").ExtractedMessage[];
 }>;
 export default _default;

package/dist/lingui-extract-experimental.js

@@ -1,17 +1,22 @@
 import { program } from "commander";
-import { getConfig } from "@lingui/conf";
+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 { createEsbuildBundler } from "./extract-experimental/bundlers/esbuild.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 { extractFromChunk } from "./extract-experimental/extractFromChunk.js";
+import { writeCatalogs, writeTemplate, } from "./extract-experimental/writeCatalogs.js";
 import { createExtractExperimentalWorkerPool } from "./api/workerPools.js";
+import { buildChunkGraph } from "./extract-experimental/buildChunkGraph.js";
+import { mergeExtractedMessage } from "./api/catalog/extractFromFiles.js";
+import ora from "ora";
+import ms from "ms";
 export default async function command(linguiConfig, options) {
-    options.verbose && console.log("Extracting messages from source files…");
+    const startTime = Date.now();
     const extractorConfig = linguiConfig.experimental?.extractor;
     if (!extractorConfig) {
         throw new Error("The configuration for experimental extractor is empty. Please read the docs.");
@@ -22,6 +27,23 @@ export default async function command(linguiConfig, options) {
             " Use at your own risk.",
         "",
     ].join("\n")));
+    // important to initialize ora before worker pool, otherwise it causes
+    // MaxListenersExceededWarning when workers >= 10
+    const spinner = ora();
+    // Phase: Resolve entry points
+    spinner.start("Resolving entry points...");
+    let phaseStart = Date.now();
+    const entryPoints = globSync(extractorConfig.entries);
+    if (entryPoints.length === 0) {
+        spinner.warn(`No entry points found (${ms(Date.now() - phaseStart)})`);
+        return true;
+    }
+    const displayEntries = entryPoints
+        .map((e) => normalizePath(nodepath.relative(linguiConfig.rootDir, e)))
+        .slice(0, 10);
+    const moreCount = entryPoints.length - displayEntries.length;
+    const entrySummary = displayEntries.join(", ") + (moreCount > 0 ? ` and ${moreCount} more` : "");
+    spinner.succeed(`Found ${entryPoints.length} entry point(s) (${ms(Date.now() - phaseStart)}): ${entrySummary}`);
     // unfortunately we can't use os.tmpdir() in this case
     // on windows it might create a folder on a different disk then source code is stored
     // (tmpdir would be always on C: but code could be stored on D:)
@@ -32,9 +54,29 @@ export default async function command(linguiConfig, options) {
     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);
+    let bundler;
+    if (extractorConfig.bundler) {
+        bundler = extractorConfig.bundler;
+    }
+    else {
+        bundler = createEsbuildBundler({
+            includeDeps: extractorConfig.includeDeps,
+            excludeExtensions: extractorConfig.excludeExtensions,
+            resolveEsbuildOptions: extractorConfig.resolveEsbuildOptions,
+        });
+    }
+    // Phase: Bundling
+    spinner.start("Bundling...");
+    phaseStart = Date.now();
+    const bundleResult = await bundler.bundle(entryPoints, tempDir, linguiConfig);
+    spinner.succeed(`Bundling done (${ms(Date.now() - phaseStart)})`);
+    const resolvedChunks = buildChunkGraph(bundleResult.chunks);
     const stats = [];
     let commandSuccess = true;
+    // Phase: Extract messages from each chunk
+    spinner.start("Extracting messages...");
+    phaseStart = Date.now();
+    const messagesByEntry = new Map();
     if (options.workersOptions.poolSize) {
         const resolvedConfigPath = linguiConfig.resolvedConfigPath;
         if (!resolvedConfigPath) {
@@ -46,14 +88,17 @@ export default async function command(linguiConfig, options) {
             poolSize: options.workersOptions.poolSize,
         });
         try {
-            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: normalizePath(nodepath.relative(linguiConfig.rootDir, entryPoint)),
-                        content: result.stat,
+            await Promise.all(resolvedChunks.map(async ({ filePath, entryPoints }) => {
+                const { messages, success } = await pool.run(resolvedConfigPath, filePath);
+                if (!success) {
+                    commandSuccess = false;
+                }
+                for (const entryPoint of entryPoints) {
+                    if (!messagesByEntry.has(entryPoint)) {
+                        messagesByEntry.set(entryPoint, {});
+                    }
+                    messages.forEach((message) => {
+                        mergeExtractedMessage(message, messagesByEntry.get(entryPoint), linguiConfig);
                     });
                 }
             }));
@@ -63,29 +108,57 @@ export default async function command(linguiConfig, options) {
         }
     }
     else {
-        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: extractorConfig.output,
+        await Promise.all(resolvedChunks.map(async ({ filePath, entryPoints }) => {
+            const { messages, success } = await extractFromChunk(filePath, linguiConfig);
+            if (!success) {
+                commandSuccess = false;
+            }
+            for (const entryPoint of entryPoints) {
+                if (!messagesByEntry.has(entryPoint)) {
+                    messagesByEntry.set(entryPoint, {});
+                }
+                messages.forEach((message) => {
+                    mergeExtractedMessage(message, messagesByEntry.get(entryPoint), linguiConfig);
+                });
+            }
+        }));
+    }
+    spinner.succeed(`Extracting done (${ms(Date.now() - phaseStart)})`);
+    // Phase: Write catalogs per entry point
+    spinner.start("Writing catalogs...");
+    phaseStart = Date.now();
+    const format = await getFormat(linguiConfig.format, linguiConfig.sourceLocale);
+    const locales = options.locales || linguiConfig.locales;
+    for (const [entryPoint, messages] of messagesByEntry) {
+        let stat;
+        if (options.template) {
+            stat = (await writeTemplate({
+                linguiConfig,
+                clean: options.clean || false,
                 format,
+                messages,
+                entryPoint,
+                outputPattern: extractorConfig.output,
+            })).statMessage;
+        }
+        else {
+            stat = (await writeCatalogs({
+                locales,
                 linguiConfig,
-                locales: options.locales || linguiConfig.locales,
-                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,
-                });
-            }
+                format,
+                messages,
+                entryPoint,
+                overwrite: options.overwrite || false,
+                outputPattern: extractorConfig.output,
+            })).statMessage;
         }
+        stats.push({
+            entry: normalizePath(nodepath.relative(linguiConfig.rootDir, entryPoint)),
+            content: stat,
+        });
     }
+    spinner.succeed(`Writing catalogs done (${ms(Date.now() - phaseStart)})`);
     // cleanup temp directory
     await fs.rm(tempDir, { recursive: true, force: true });
     stats
@@ -93,6 +166,13 @@ export default async function command(linguiConfig, options) {
         .forEach(({ entry, content }) => {
         console.log([`Catalog statistics for ${entry}:`, content, ""].join("\n"));
     });
+    const totalTime = Date.now() - startTime;
+    if (commandSuccess) {
+        console.log(styleText("green", `Extraction completed successfully in ${ms(totalTime)}`));
+    }
+    else {
+        console.log(styleText("red", `Extraction completed with errors in ${ms(totalTime)}`));
+    }
     return commandSuccess;
 }
 if (import.meta.main) {

package/dist/services/translationIO.js

@@ -7,7 +7,7 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 const getTargetLocales = (config) => {
     const sourceLocale = config.sourceLocale || "en";
-    const pseudoLocale = config.pseudoLocale || "pseudo";
+    const pseudoLocale = config.pseudoLocale.locale || "pseudo";
     return config.locales.filter((value) => value != sourceLocale && value != pseudoLocale);
 };
 // Main sync method, call "Init" or "Sync" depending on the project context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingui/cli",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "description": "Lingui CLI to extract messages, compile catalogs, and manage translation workflows",
   "type": "module",
   "keywords": [
@@ -33,7 +33,9 @@
   "exports": {
     ".": "./dist/index.js",
     "./api": "./dist/api/index.js",
-    "./api/extractors/babel": "./dist/api/extractors/babel.js"
+    "./api/extractors/babel": "./dist/api/extractors/babel.js",
+    "./bundlers/esbuild": "./dist/extract-experimental/bundlers/esbuild.js",
+    "./bundlers/rolldown": "./dist/extract-experimental/bundlers/rolldown.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -52,16 +54,15 @@
     "@babel/generator": "^7.28.5",
     "@babel/parser": "^7.22.0",
     "@babel/types": "^7.21.2",
-    "@lingui/babel-plugin-extract-messages": "6.4.0",
-    "@lingui/babel-plugin-lingui-macro": "6.4.0",
-    "@lingui/conf": "6.4.0",
-    "@lingui/core": "6.4.0",
-    "@lingui/format-po": "6.4.0",
-    "@lingui/message-utils": "6.4.0",
+    "@lingui/babel-plugin-extract-messages": "6.6.0",
+    "@lingui/babel-plugin-lingui-macro": "6.6.0",
+    "@lingui/conf": "6.6.0",
+    "@lingui/core": "6.6.0",
+    "@lingui/format-po": "6.6.0",
+    "@lingui/message-utils": "6.6.0",
     "chokidar": "5.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
-    "esbuild": "^0.25.1",
     "jiti": "^2.6.1",
     "micromatch": "^4.0.7",
     "ms": "^2.1.3",
@@ -71,15 +72,30 @@
     "source-map": "^0.7.6",
     "tinypool": "^2.1.0"
   },
+  "peerDependencies": {
+    "esbuild": "^0.28.1",
+    "rolldown": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    },
+    "rolldown": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@lingui/test-utils": "3.0.3",
+    "@rolldown/plugin-babel": "^0.2.3",
     "@types/babel__generator": "^7.27.0",
     "@types/micromatch": "^4.0.1",
     "@types/ms": "^2.1.0",
     "@types/normalize-path": "^3.0.0",
+    "esbuild": "^0.28.1",
     "mock-fs": "^5.2.0",
     "msw": "^2.12.7",
+    "rolldown": "^1.1.1",
     "vitest": "catalog:"
   },
-  "gitHead": "e8657bf8cbe6e8abc62a46a24e018ff9812918be"
+  "gitHead": "665a19815378dedd89346bb7707bdb0e28df79e7"
 }

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

@@ -1,3 +0,0 @@
-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,75 +0,0 @@
-import { pluginLinguiMacro } from "./linguiEsbuildPlugin.js";
-import { buildIncludeDepsFilter } from "./buildIncludeDepsFilter.js";
-function createExtRegExp(extensions) {
-    return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
-}
-export async function bundleSource(linguiConfig, extractorConfig, entryPoints, outDir, rootDir) {
-    const esbuild = await import("esbuild");
-    const excludeExtensions = extractorConfig.excludeExtensions || [
-        "ico",
-        "pot",
-        "xliff",
-        "woff2",
-        "woff",
-        "eot",
-        "gif",
-        "otf",
-        "ttf",
-        "mp4",
-        "svg",
-        "png",
-        "css",
-        "sass",
-        "scss",
-        "less",
-        "jpg",
-    ];
-    const esbuildOptions = {
-        entryPoints: entryPoints,
-        outExtension: { ".js": ".jsx" },
-        jsx: "preserve",
-        bundle: true,
-        platform: "node",
-        target: ["esnext"],
-        format: "esm",
-        splitting: false,
-        treeShaking: true,
-        outdir: outDir,
-        sourcemap: "inline",
-        sourceRoot: outDir,
-        sourcesContent: false,
-        metafile: true,
-        plugins: [
-            pluginLinguiMacro({ linguiConfig }),
-            {
-                name: "externalize-deps",
-                setup(build) {
-                    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) || args.kind === "entry-point") {
-                            return { external: false };
-                        }
-                        return {
-                            external: true,
-                        };
-                    });
-                },
-            },
-            {
-                name: "externalize-files",
-                setup(build) {
-                    build.onResolve({ filter: createExtRegExp(excludeExtensions) }, () => ({
-                        external: true,
-                    }));
-                },
-            },
-        ],
-    };
-    const bundleResult = await esbuild.build(extractorConfig.resolveEsbuildOptions
-        ? extractorConfig.resolveEsbuildOptions(esbuildOptions)
-        : esbuildOptions);
-    return bundleResult.metafile;
-}

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

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

package/dist/extract-experimental/extractFromBundleAndWrite.js

@@ -1,50 +0,0 @@
-import { mergeExtractedMessage } from "../api/catalog/extractFromFiles.js";
-import { writeCatalogs, writeTemplate } from "./writeCatalogs.js";
-import extract from "../api/extractors/index.js";
-async function extractFromBundle(filename, linguiConfig) {
-    const messages = {};
-    let success;
-    try {
-        await extract(filename, (msg) => {
-            mergeExtractedMessage(msg, messages, linguiConfig);
-        }, linguiConfig);
-        success = true;
-    }
-    catch (e) {
-        console.error(`Cannot process file ${filename} ${e.message}`);
-        console.error(e.stack);
-        success = false;
-    }
-    return { success, messages };
-}
-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) {
-        return { success: false };
-    }
-    let stat;
-    if (template) {
-        stat = (await writeTemplate({
-            linguiConfig,
-            clean,
-            format,
-            messages,
-            entryPoint,
-            outputPattern,
-        })).statMessage;
-    }
-    else {
-        stat = (await writeCatalogs({
-            locales,
-            linguiConfig,
-            clean,
-            format,
-            messages,
-            entryPoint,
-            overwrite,
-            outputPattern,
-        })).statMessage;
-    }
-    return { success: true, stat };
-}

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

@@ -1,5 +0,0 @@
-import { Plugin } from "esbuild";
-import { LinguiConfigNormalized } from "@lingui/conf";
-export declare const pluginLinguiMacro: (options: {
-    linguiConfig: LinguiConfigNormalized;
-}) => Plugin;

package/dist/extract-experimental/linguiEsbuildPlugin.js

@@ -1,38 +0,0 @@
-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: 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 transformAsync(contents, {
-                babelrc: false,
-                configFile: false,
-                filename: filename,
-                sourceMaps: "inline",
-                parserOpts: {
-                    plugins: getBabelParserOptions(filename, {}),
-                },
-                plugins: [
-                    [
-                        linguiMacroPlugin,
-                        {
-                            descriptorFields: "all",
-                            linguiConfig: options.linguiConfig,
-                        },
-                    ],
-                ],
-            });
-            return { contents: result.code, loader: "tsx" };
-        });
-    },
-});