@lingui/cli 6.7.0 → 6.8.0

package/dist/api/check/types.js

@@ -0,0 +1,13 @@
+export const checkSpecificOptions = [
+    "clean",
+    "overwrite",
+    "missingBehavior",
+];
+export function finalizeCheckResult(name, findings, passMessage, failMessage) {
+    return {
+        name,
+        passed: findings.length === 0,
+        findings,
+        summary: findings.length === 0 ? passMessage : failMessage(findings.length),
+    };
+}

package/dist/api/compile/compileLocale.js

@@ -5,8 +5,9 @@ import { ProgramExit } from "../ProgramExit.js";
 import { createCompiledCatalog } from "../compile.js";
 import normalizePath from "normalize-path";
 import nodepath from "path";
-import { createCompilationErrorMessage } from "../messages.js";
+import { createCompilationErrorMessage, getMissingBehaviorDescription, } from "../messages.js";
 import { getTranslationsForCatalog } from "../catalog/getTranslationsForCatalog.js";
+import { createMissingTranslationFinding } from "../catalog/translations.js";
 export async function compileLocale(catalogs, locale, options, config, doMerge, logger) {
     let mergedCatalogs = {};
     for (const catalog of catalogs) {
@@ -20,16 +21,14 @@ export async function compileLocale(catalogs, locale, options, config, doMerge,
             missingMessages.length > 0) {
             logger.error(styleText("red", `Error: Failed to compile catalog for locale ${styleText("bold", locale)}!`));
             if (options.verbose) {
-                logger.error(styleText("red", "Missing translations:"));
+                logger.error(styleText("red", `Missing translations ${getMissingBehaviorDescription("resolved")}:`));
                 missingMessages.forEach((missing) => {
-                    const source = missing.source || missing.source === missing.id
-                        ? `: (${missing.source})`
-                        : "";
-                    logger.error(`${missing.id}${source}`);
+                    const finding = createMissingTranslationFinding(catalog, locale, missing);
+                    logger.error(`${finding.catalogPath}: ${finding.message}`);
                 });
             }
             else {
-                logger.error(styleText("red", `Missing ${missingMessages.length} translation(s)`));
+                logger.error(styleText("red", `Missing ${missingMessages.length} translation(s) ${getMissingBehaviorDescription("resolved")}`));
             }
             logger.error("");
             throw new ProgramExit();

package/dist/api/extractors/index.d.ts

@@ -1,5 +1,2 @@
-import { Experimental__BatchExtractorType, ExtractedMessage, ExtractorType, LinguiConfigNormalized, PerFileExtractorType } from "@lingui/conf";
-export declare function isBatchExtractor(ext: ExtractorType): ext is Experimental__BatchExtractorType;
-export declare function isPerFileExtractor(ext: ExtractorType): ext is PerFileExtractorType;
-export declare const getConfiguredExtractors: (linguiConfig: LinguiConfigNormalized) => ExtractorType[];
+import { ExtractedMessage, LinguiConfigNormalized } from "@lingui/conf";
 export default function extract(filename: string, onMessageExtracted: (msg: ExtractedMessage) => void, linguiConfig: LinguiConfigNormalized): Promise<boolean>;

package/dist/api/extractors/index.js

@@ -9,17 +9,10 @@ function createDefaultExtractor(linguiConfig) {
     }
     return defaultExtractor;
 }
-export function isBatchExtractor(ext) {
-    return "extractFromFiles" in ext && typeof ext.extractFromFiles === "function";
-}
-export function isPerFileExtractor(ext) {
-    return "extract" in ext && typeof ext.extract === "function";
-}
-export const getConfiguredExtractors = (linguiConfig) => {
-    return linguiConfig.extractors ?? [createDefaultExtractor(linguiConfig)];
-};
 export default async function extract(filename, onMessageExtracted, linguiConfig) {
-    const extractorsToExtract = getConfiguredExtractors(linguiConfig).filter(isPerFileExtractor);
+    const extractorsToExtract = linguiConfig.extractors ?? [
+        createDefaultExtractor(linguiConfig),
+    ];
     for (const ext of extractorsToExtract) {
         if (!ext.match(filename))
             continue;

package/dist/api/formats/formatterWrapper.d.ts

@@ -5,6 +5,7 @@ export declare class FormatterWrapper {
     constructor(f: CatalogFormatter, sourceLocale: string);
     getCatalogExtension(): string;
     getTemplateExtension(): string;
+    serialize(filename: string, catalog: CatalogType, locale?: string, existing?: string): Promise<string>;
     write(filename: string, catalog: CatalogType, locale?: string): Promise<void>;
     read(filename: string, locale: string | undefined): Promise<CatalogType | undefined>;
 }

package/dist/api/formats/formatterWrapper.js

@@ -1,4 +1,4 @@
-import { readFile, writeFileIfChanged } from "../utils.js";
+import { readFile, writeFile } from "../utils.js";
 import { RethrownError } from "../rethrownError.js";
 export class FormatterWrapper {
     f;
@@ -13,14 +13,21 @@ export class FormatterWrapper {
     getTemplateExtension() {
         return this.f.templateExtension || this.f.catalogExtension;
     }
-    async write(filename, catalog, locale) {
-        const content = await this.f.serialize(catalog, {
+    async serialize(filename, catalog, locale, existing) {
+        const resolvedExisting = arguments.length >= 4 ? existing : await readFile(filename);
+        return await this.f.serialize(catalog, {
             locale,
             sourceLocale: this.sourceLocale,
-            existing: await readFile(filename),
+            existing: resolvedExisting,
             filename,
         });
-        await writeFileIfChanged(filename, content);
+    }
+    async write(filename, catalog, locale) {
+        const existing = await readFile(filename);
+        const content = await this.serialize(filename, catalog, locale, existing);
+        if (content !== existing) {
+            await writeFile(filename, content);
+        }
     }
     async read(filename, locale) {
         const content = await readFile(filename);

package/dist/api/index.d.ts

@@ -3,5 +3,7 @@ export { getCatalogForFile, getCatalogs } from "./catalog/getCatalogs.js";
 export { createCompiledCatalog } from "./compile.js";
 export { default as extractor, extractFromFileWithBabel, } from "./extractors/babel.js";
 export { getCatalogDependentFiles } from "./catalog/getCatalogDependentFiles.js";
-export { createMissingErrorMessage, createCompilationErrorMessage, } from "./messages.js";
+export { createMissingErrorMessage, createCompilationErrorMessage, isFailOnMissingEnabled, getFailOnMissingBehavior, formatFailOnMissingOption, } from "./messages.js";
+export type { FailOnMissingOption } from "./messages.js";
+export type { MissingBehavior } from "./catalog/getTranslationsForCatalog.js";
 export * from "./types.js";

package/dist/api/index.js

@@ -3,5 +3,5 @@ export { getCatalogForFile, getCatalogs } from "./catalog/getCatalogs.js";
 export { createCompiledCatalog } from "./compile.js";
 export { default as extractor, extractFromFileWithBabel, } from "./extractors/babel.js";
 export { getCatalogDependentFiles } from "./catalog/getCatalogDependentFiles.js";
-export { createMissingErrorMessage, createCompilationErrorMessage, } from "./messages.js";
+export { createMissingErrorMessage, createCompilationErrorMessage, isFailOnMissingEnabled, getFailOnMissingBehavior, formatFailOnMissingOption, } from "./messages.js";
 export * from "./types.js";

package/dist/api/messages.d.ts

@@ -1,4 +1,10 @@
-import { TranslationMissingEvent } from "./catalog/getTranslationsForCatalog.js";
-import { MessageCompilationError } from "./compile.js";
+import { type MissingBehavior, type TranslationMissingEvent } from "./catalog/getTranslationsForCatalog.js";
+import type { MessageCompilationError } from "./compile.js";
+export declare function getMissingBehaviorDescription(missingBehavior: MissingBehavior): "before applying fallbackLocales" | "after applying fallbackLocales";
+export type FailOnMissingOption = boolean | MissingBehavior;
+export declare function isFailOnMissingEnabled(option: FailOnMissingOption | undefined): option is true | "resolved" | "catalog";
+export declare function getFailOnMissingBehavior(option: FailOnMissingOption | undefined): MissingBehavior;
+export declare function formatFailOnMissingOption(option: FailOnMissingOption | undefined): "true" | "\"resolved\"" | "\"catalog\"" | "false";
 export declare function createMissingErrorMessage(locale: string, missingMessages: TranslationMissingEvent[], configurationMsg: string): string;
+export declare function createMissingErrorMessage(locale: string, missingMessages: TranslationMissingEvent[], missingBehavior?: MissingBehavior): string;
 export declare function createCompilationErrorMessage(locale: string, errors: MessageCompilationError[]): string;

package/dist/api/messages.js

@@ -1,8 +1,35 @@
+import { isMissingBehavior, } from "./catalog/getTranslationsForCatalog.js";
 import { styleText } from "node:util";
-export function createMissingErrorMessage(locale, missingMessages, configurationMsg) {
+export function getMissingBehaviorDescription(missingBehavior) {
+    return missingBehavior === "catalog"
+        ? "before applying fallbackLocales"
+        : "after applying fallbackLocales";
+}
+export function isFailOnMissingEnabled(option) {
+    return option === true || option === "resolved" || option === "catalog";
+}
+export function getFailOnMissingBehavior(option) {
+    return option === "catalog" ? "catalog" : "resolved";
+}
+export function formatFailOnMissingOption(option) {
+    if (option === true)
+        return "true";
+    if (option === "resolved")
+        return '"resolved"';
+    if (option === "catalog")
+        return '"catalog"';
+    return "false";
+}
+export function createMissingErrorMessage(locale, missingMessages, missingBehaviorOrConfigurationMsg = "resolved") {
+    const missingBehavior = isMissingBehavior(missingBehaviorOrConfigurationMsg ?? "")
+        ? missingBehaviorOrConfigurationMsg
+        : undefined;
+    const missingBehaviorDescription = missingBehavior
+        ? ` ${getMissingBehaviorDescription(missingBehavior)}`
+        : "";
     let message = `Failed to compile catalog for locale ${styleText("bold", locale)}!
 
-Missing ${missingMessages.length} translation(s):
+Missing ${missingMessages.length} translation(s)${missingBehaviorDescription}:
 \n`;
     missingMessages.forEach((missing) => {
         const source = missing.source || missing.source === missing.id

package/dist/api/resolveWorkersOptions.js

@@ -1,15 +1,29 @@
 import * as os from "node:os";
+function parseWorkers(workers) {
+    if (workers === undefined) {
+        return undefined;
+    }
+    const parsedWorkers = Number(workers);
+    if (!Number.isFinite(parsedWorkers) || !Number.isInteger(parsedWorkers)) {
+        throw new Error("The `--workers` option must be an integer.");
+    }
+    return parsedWorkers;
+}
 export function resolveWorkersOptions(opts) {
     const cores = os.availableParallelism();
-    if (Number(opts.workers) <= 1 || cores === 1) {
+    const workers = parseWorkers(opts.workers);
+    if (workers !== undefined && workers <= 1) {
+        return { poolSize: 0 };
+    }
+    if (cores === 1) {
         return { poolSize: 0 };
     }
-    if (!opts.workers) {
+    if (workers === undefined) {
         if (cores <= 2) {
             return { poolSize: cores }; // on tiny machines, use all
         }
         // on big machines cap to 8, to avoid trashing
         return { poolSize: Math.min(cores - 1, 8) };
     }
-    return { poolSize: Number(opts.workers) };
+    return { poolSize: workers };
 }

package/dist/api/runBounded.d.ts

@@ -0,0 +1 @@
+export declare function runBounded<T, R>(items: readonly T[], concurrency: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/api/runBounded.js

@@ -0,0 +1,13 @@
+export async function runBounded(items, concurrency, worker) {
+    const results = new Array(items.length);
+    const workerCount = Math.min(Math.max(concurrency, 1), items.length);
+    let nextIndex = 0;
+    const pool = Array.from({ length: workerCount }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex++;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(pool);
+    return results;
+}

package/dist/api/utils.d.ts

@@ -14,6 +14,11 @@ export declare function makeInstall(packageName: string, dev?: boolean): string;
  * Preserve absolute paths:    /absolute/path => /absolute/path
  */
 export declare function normalizeRelativePath(sourcePath: string): string;
+/**
+ * Normalize a path relative to the project rootDir, for display purposes
+ * (e.g. finding.catalogPath).
+ */
+export declare function toRootRelativePath(rootDir: string, filePath: string): string;
 /**
  * Escape special regex characters used in file-based routing systems
  */

package/dist/api/utils.js

@@ -87,6 +87,13 @@ export function normalizeRelativePath(sourcePath) {
     return (normalizePath(path.relative(process.cwd(), sourcePath), false) +
         (isDir ? "/" : ""));
 }
+/**
+ * Normalize a path relative to the project rootDir, for display purposes
+ * (e.g. finding.catalogPath).
+ */
+export function toRootRelativePath(rootDir, filePath) {
+    return normalizePath(path.relative(rootDir, filePath));
+}
 /**
  * Escape special regex characters used in file-based routing systems
  */

package/dist/api/workerPools.d.ts

@@ -1,3 +1,5 @@
 import { WorkerPool } from "./typedPool.js";
 import type { ExtractWorkerFunction } from "../workers/extractWorker.js";
+import type { MissingWorkerFunction } from "../workers/missingWorker.js";
 export type ExtractWorkerPool = WorkerPool<ExtractWorkerFunction>;
+export type MissingWorkerPool = WorkerPool<MissingWorkerFunction>;

package/dist/api/workerPools.js

@@ -5,3 +5,5 @@ export const createExtractWorkerPool = (opts) => createWorkerPool("../workers/ex
 export const createExtractExperimentalWorkerPool = (opts) => createWorkerPool("../extract-experimental/workers/extractWorkerWrapper", import.meta.url, opts.poolSize);
 /** @internal */
 export const createCompileWorkerPool = (opts) => createWorkerPool("../workers/compileWorkerWrapper", import.meta.url, opts.poolSize);
+/** @internal */
+export const createMissingWorkerPool = (opts) => createWorkerPool("../workers/missingWorkerWrapper", import.meta.url, opts.poolSize);

package/dist/index.d.ts

@@ -1 +1 @@
-export { defineConfig } from "@lingui/conf";
+export { defineConfig, type LinguiConfig } from "@lingui/conf";

package/dist/index.js

@@ -1 +1,2 @@
+// Re-export both the `defineConfig` function and the types it depends on
 export { defineConfig } from "@lingui/conf";

package/dist/lingui-check.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { CheckName, CheckRunOptions, CheckResult } from "./api/check/types.js";
+export declare function renderCheckResult(result: CheckResult, verbose: boolean): string[];
+export declare function runCheck(config: LinguiConfigNormalized, check: CheckName, options: CheckRunOptions): Promise<CheckResult>;
+export declare function createProgram(): Command;

package/dist/lingui-check.js

@@ -0,0 +1,137 @@
+import { styleText } from "node:util";
+import { Command } from "commander";
+import ms from "ms";
+import { getConfig } from "@lingui/conf";
+import { helpRun } from "./api/help.js";
+import { getCatalogs } from "./api/index.js";
+import { getCheck, getRegisteredChecks, validateSupportedOptions, } from "./api/check/index.js";
+import { resolveWorkersOptions } from "./api/resolveWorkersOptions.js";
+import { isMissingBehavior } from "./api/catalog/getTranslationsForCatalog.js";
+export function renderCheckResult(result, verbose) {
+    const status = result.passed
+        ? styleText("green", "PASS")
+        : styleText("red", "FAIL");
+    const lines = [`${status} ${result.name}: ${result.summary}`];
+    if (verbose) {
+        lines.push(...result.findings.map((finding) => `${finding.catalogPath}: ${finding.message}`));
+    }
+    return lines;
+}
+function validateLocales(config, locales) {
+    if (!locales?.length) {
+        return config.locales;
+    }
+    const missingLocale = locales.find((locale) => !config.locales.includes(locale));
+    if (missingLocale) {
+        throw new Error(`Locale ${styleText("bold", missingLocale)} does not exist.`);
+    }
+    return locales;
+}
+export async function runCheck(config, check, options) {
+    const checkDefinition = getCheck(check);
+    validateSupportedOptions(checkDefinition, options);
+    const locales = validateLocales(config, options.locale);
+    const catalogs = await getCatalogs(config);
+    return await checkDefinition.run({
+        config,
+        catalogs,
+        locales,
+        workersOptions: options.workersOptions,
+        clean: options.clean ?? false,
+        overwrite: options.overwrite ?? false,
+        missingBehavior: options.missingBehavior ?? "resolved",
+    });
+}
+function parseLocales(value) {
+    return value
+        .split(",")
+        .map((locale) => locale.trim())
+        .filter(Boolean);
+}
+function addCommonOptions(command) {
+    return command
+        .option("--config <path>", "Path to the config file")
+        .option("--locale <locale, [...]>", "Only check the specified locales", parseLocales)
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8; on 1-2 core machines, all cores). Pass `--workers 1` to disable worker threads and run everything in a single process")
+        .option("--verbose", "Verbose output");
+}
+function parseMissingBehavior(value) {
+    if (isMissingBehavior(value)) {
+        return value;
+    }
+    throw new Error("Option `--mode` must be either `resolved` or `catalog`.");
+}
+function renderHelpExamples(examples) {
+    if (!examples.length) {
+        return;
+    }
+    console.log("\n  Examples:\n");
+    examples.forEach((example, index) => {
+        console.log(`    # ${example.description}`);
+        console.log(`    $ ${helpRun(example.command)}`);
+        if (index < examples.length - 1) {
+            console.log("");
+        }
+    });
+}
+async function runCliCommand(check, options) {
+    const startTime = Date.now();
+    const config = getConfig({ configPath: options.config });
+    const verbose = options.verbose ?? false;
+    console.log("Checking message catalogs…");
+    const result = await runCheck(config, check, {
+        locale: options.locale,
+        workersOptions: resolveWorkersOptions(options),
+        clean: options.clean,
+        overwrite: options.overwrite,
+        missingBehavior: options.mode,
+    });
+    const output = result.passed ? console.log : console.error;
+    renderCheckResult(result, verbose).forEach((line) => {
+        output(line);
+    });
+    console.log(`Done in ${ms(Date.now() - startTime)}`);
+    return result.passed;
+}
+function registerCheckCommand(checkProgram, check) {
+    const command = addCommonOptions(checkProgram.command(check.name).description(check.description));
+    check.cli.options.forEach((option) => {
+        if (option.name === "mode") {
+            command.option(`--${option.name} <mode>`, option.description, parseMissingBehavior);
+            return;
+        }
+        command.option(`--${option.name}`, option.description);
+    });
+    command
+        .on("--help", function () {
+        renderHelpExamples(check.cli.examples);
+    })
+        .action(async (options) => {
+        if (!(await runCliCommand(check.name, options))) {
+            process.exitCode = 1;
+        }
+    });
+}
+export function createProgram() {
+    const checkProgram = new Command()
+        .name("lingui check")
+        .description("Check message catalogs.")
+        .action(() => {
+        checkProgram.help({ error: true });
+    })
+        .on("--help", function () {
+        renderHelpExamples(getRegisteredChecks().flatMap((check) => check.cli.examples));
+    });
+    getRegisteredChecks().forEach((check) => {
+        registerCheckCommand(checkProgram, check);
+    });
+    return checkProgram;
+}
+if (import.meta.main) {
+    createProgram()
+        .parseAsync(process.argv)
+        .catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/lingui-compile.js

@@ -9,6 +9,7 @@ import { createCompileWorkerPool } from "./api/workerPools.js";
 import { resolveWorkersOptions, } from "./api/resolveWorkersOptions.js";
 import ms from "ms";
 import { getPathsForCompileWatcher } from "./api/getPathsForCompileWatcher.js";
+import { ProgramExit } from "./api/ProgramExit.js";
 export async function command(config, options) {
     const startTime = Date.now();
     // Check config.compile.merge if catalogs for current locale are to be merged into a single compiled file
@@ -23,7 +24,7 @@ export async function command(config, options) {
                 await compileLocale(catalogs, locale, options, config, doMerge, console);
             }
             catch (err) {
-                if (err.name === "ProgramExit") {
+                if (err instanceof ProgramExit) {
                     errored = true;
                 }
                 else {
@@ -68,10 +69,10 @@ if (import.meta.main) {
     program
         .description("Compile message catalogs to compiled bundle.")
         .option("--config <path>", "Path to the config file")
-        .option("--strict", "Disable defaults for missing translations")
+        .option("--strict", "Fail if translations are missing after applying fallbackLocales, or if compilation errors occur")
         .option("--verbose", "Verbose output")
         .option("--typescript", "Create Typescript definition for compiled bundle")
-        .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")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8; on 1-2 core machines, all cores). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .option("--namespace <namespace>", "Specify namespace for compiled bundle. Ex: cjs(default) -> module.exports, es -> export, window.test -> window.test")
         .option("--watch", "Enables Watch Mode")
         .option("--debounce <delay>", "Debounces compilation for given amount of milliseconds")
@@ -81,9 +82,8 @@ if (import.meta.main) {
         console.log("    # Compile translations and use defaults or message IDs for missing translations");
         console.log(`    $ ${helpRun("compile")}`);
         console.log("");
-        console.log("    # Compile translations but fail when there are missing");
-        console.log("    # translations (don't replace missing translations with");
-        console.log("    # default messages or message IDs)");
+        console.log("    # Compile translations but fail when resolved output");
+        console.log("    # still has missing translations or compilation errors");
         console.log(`    $ ${helpRun("compile --strict")}`);
     })
         .parse(process.argv);

package/dist/lingui-extract-experimental.js

@@ -183,7 +183,7 @@ if (import.meta.main) {
         .option("--clean", "Remove obsolete translations")
         .option("--locale <locale, [...]>", "Only extract the specified locales")
         .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")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8; on 1-2 core machines, all cores). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .parse(process.argv);
     const options = program.opts();
     const config = getConfig({

package/dist/lingui-extract-template.js

@@ -45,7 +45,7 @@ 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")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8; on 1-2 core machines, all cores). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .parse(process.argv);
     const options = program.opts();
     const config = getConfig({

package/dist/lingui-extract.js

@@ -97,7 +97,7 @@ if (import.meta.main) {
             .map((s) => s.trim())
             .filter(Boolean);
     })
-        .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")
+        .option("--workers <n>", "Number of worker threads to use (default: CPU count - 1, capped at 8; on 1-2 core machines, all cores). Pass `--workers 1` to disable worker threads and run everything in a single process")
         .option("--overwrite", "Overwrite translations for source locale")
         .option("--clean", "Remove obsolete translations")
         .option("--debounce <delay>", "Debounces extraction for given amount of milliseconds")

package/dist/lingui.js

@@ -8,5 +8,6 @@ program
     .command("extract [files...]", "Extracts messages from source files")
     .command("extract-experimental", "Extracts messages from source files traversing dependency tree")
     .command("extract-template", "Extracts messages from source files to a .pot template")
+    .command("check", "Checks message catalogs")
     .command("compile", "Compile message catalogs")
     .parse(process.argv);

package/dist/workers/missingWorker.d.ts

@@ -0,0 +1,4 @@
+import { MissingTranslationFinding } from "../api/catalog/translations.js";
+import type { MissingBehavior } from "../api/catalog/getTranslationsForCatalog.js";
+export type MissingWorkerFunction = typeof missingWorker;
+export declare const missingWorker: (catalogPath: string, locale: string, missingBehavior: MissingBehavior, linguiConfigPath: string) => Promise<MissingTranslationFinding[]>;

package/dist/workers/missingWorker.js

@@ -0,0 +1,23 @@
+import { getConfig } from "@lingui/conf";
+import { getCatalogs } from "../api/catalog/getCatalogs.js";
+import { getMissingTranslationFindings, } from "../api/catalog/translations.js";
+let linguiConfig;
+let catalogs;
+export const missingWorker = async (catalogPath, locale, missingBehavior, linguiConfigPath) => {
+    if (!linguiConfig) {
+        // initialize config once per worker, speed up workers follow execution
+        linguiConfig = getConfig({
+            configPath: linguiConfigPath,
+            skipValidation: true,
+        });
+    }
+    if (!catalogs) {
+        // catalogs depend only on the config, so initialize them once per worker
+        catalogs = await getCatalogs(linguiConfig);
+    }
+    const catalog = catalogs.find((catalog) => catalog.path === catalogPath);
+    if (!catalog) {
+        throw new Error(`Unable to find catalog at path ${catalogPath}.`);
+    }
+    return getMissingTranslationFindings(catalog, locale, missingBehavior);
+};

package/dist/workers/missingWorkerWrapper.prod.d.ts

@@ -0,0 +1,3 @@
+import { missingWorker } from "./missingWorker.js";
+declare const _default: (args: Parameters<typeof missingWorker>) => Promise<import("../api/catalog/translations.js").MissingTranslationFinding[]>;
+export default _default;

package/dist/workers/missingWorkerWrapper.prod.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingui/cli",
-  "version": "6.7.0",
+  "version": "6.8.0",
   "description": "Lingui CLI: extracts i18n messages from source code into catalogs and compiles the translated catalogs for the runtime",
   "type": "module",
   "keywords": [
@@ -54,12 +54,12 @@
     "@babel/generator": "^7.28.5",
     "@babel/parser": "^7.22.0",
     "@babel/types": "^7.21.2",
-    "@lingui/babel-plugin-extract-messages": "6.7.0",
-    "@lingui/babel-plugin-lingui-macro": "6.7.0",
-    "@lingui/conf": "6.7.0",
-    "@lingui/core": "6.7.0",
-    "@lingui/format-po": "6.7.0",
-    "@lingui/message-utils": "6.7.0",
+    "@lingui/babel-plugin-extract-messages": "6.8.0",
+    "@lingui/babel-plugin-lingui-macro": "6.8.0",
+    "@lingui/conf": "6.8.0",
+    "@lingui/core": "6.8.0",
+    "@lingui/format-po": "6.8.0",
+    "@lingui/message-utils": "6.8.0",
     "chokidar": "5.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
@@ -97,5 +97,5 @@
     "rolldown": "^1.1.1",
     "vitest": "catalog:"
   },
-  "gitHead": "a2d4b6d42e052fed1d432050b20cc56cfdacfe98"
+  "gitHead": "8c0f1ba378076cc49b320cccd2e06c60afe94963"
 }