@lingui/cli 6.6.0 → 6.8.0

package/dist/api/check/sync.js

@@ -0,0 +1,96 @@
+import { cleanObsolete, order } from "../catalog.js";
+import { runBounded } from "../runBounded.js";
+import { createExtractWorkerPool } from "../workerPools.js";
+import { readFile, toRootRelativePath } from "../utils.js";
+import { finalizeCheckResult, } from "./types.js";
+function getSyncFailureSummary(findings) {
+    const outOfSyncCount = findings.filter((finding) => finding.code === "catalog_out_of_sync").length;
+    const extractionFailureCount = findings.filter((finding) => finding.code === "extract_failed").length;
+    if (extractionFailureCount === 0) {
+        return `Found ${outOfSyncCount} out-of-sync catalog file(s).`;
+    }
+    if (outOfSyncCount === 0) {
+        return `Found ${extractionFailureCount} extraction failure(s).`;
+    }
+    return `Found ${outOfSyncCount} out-of-sync catalog file(s) and ${extractionFailureCount} extraction failure(s).`;
+}
+async function getCatalogSyncFindings(catalog, ctx, workerPool) {
+    const [nextCatalog, prevCatalogs] = await Promise.all([
+        catalog.collect({ workerPool }),
+        catalog.readAll(ctx.locales),
+    ]);
+    if (!nextCatalog) {
+        return [
+            {
+                code: "extract_failed",
+                message: "Failed to extract messages",
+                catalogPath: toRootRelativePath(ctx.config.rootDir, catalog.path),
+            },
+        ];
+    }
+    const mergedCatalogs = catalog.merge(prevCatalogs, nextCatalog, {
+        overwrite: ctx.overwrite,
+    });
+    const findings = await runBounded(ctx.locales, ctx.workersOptions.poolSize, async (locale) => {
+        const filename = catalog.getFilename(locale);
+        const catalogPath = toRootRelativePath(ctx.config.rootDir, filename);
+        let nextLocaleCatalog = mergedCatalogs[locale];
+        if (ctx.clean) {
+            nextLocaleCatalog = cleanObsolete(nextLocaleCatalog);
+        }
+        const existing = await readFile(filename);
+        const expected = await catalog.format.serialize(filename, order(ctx.config.orderBy, nextLocaleCatalog), locale, existing);
+        if (existing === expected) {
+            return undefined;
+        }
+        return {
+            code: "catalog_out_of_sync",
+            message: existing !== undefined
+                ? "Catalog is out of sync with extract output"
+                : "Catalog is missing and would be created by extract",
+            locale,
+            catalogPath,
+        };
+    });
+    return findings.filter((finding) => finding !== undefined);
+}
+export const syncCheck = {
+    name: "sync",
+    description: "Verify that locale catalogs are already synchronized with what lingui extract would write.",
+    cli: {
+        options: [
+            {
+                name: "clean",
+                runOption: "clean",
+                description: "Remove obsolete messages from the expected catalog before comparing it with the existing catalog. Existing obsolete messages are reported as out of sync.",
+            },
+            {
+                name: "overwrite",
+                runOption: "overwrite",
+                description: "Mirror extract --overwrite behavior when running sync check",
+            },
+        ],
+        examples: [
+            {
+                description: "Check that catalogs are in sync with extract output",
+                command: "check sync",
+            },
+        ],
+    },
+    async run(ctx) {
+        let workerPool;
+        if (ctx.workersOptions.poolSize > 0 && ctx.config.resolvedConfigPath) {
+            workerPool = createExtractWorkerPool(ctx.workersOptions);
+        }
+        let findings;
+        try {
+            findings = (await runBounded(ctx.catalogs, ctx.workersOptions.poolSize, (catalog) => getCatalogSyncFindings(catalog, ctx, workerPool))).flat();
+        }
+        finally {
+            if (workerPool) {
+                await workerPool.destroy();
+            }
+        }
+        return finalizeCheckResult("sync", findings, "Catalogs are in sync with extract output.", () => getSyncFailureSummary(findings));
+    },
+};

package/dist/api/check/types.d.ts

@@ -0,0 +1,62 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { Catalog } from "../catalog.js";
+import { WorkersOptions } from "../resolveWorkersOptions.js";
+import type { MissingTranslationFinding } from "../catalog/translations.js";
+import type { MissingBehavior } from "../catalog/getTranslationsForCatalog.js";
+export type CheckFindingBase = {
+    catalogPath: string;
+    message: string;
+};
+export type CheckName = "sync" | "missing";
+export declare const checkSpecificOptions: readonly ["clean", "overwrite", "missingBehavior"];
+export type CheckSpecificOption = (typeof checkSpecificOptions)[number];
+export type CheckCliOptionName = "clean" | "overwrite" | "mode";
+export type CheckCliExample = {
+    description: string;
+    command: string;
+};
+export type CheckCliOptionDefinition = {
+    name: CheckCliOptionName;
+    runOption: CheckSpecificOption;
+    description: string;
+};
+export type CatalogOutOfSyncFinding = CheckFindingBase & {
+    code: "catalog_out_of_sync";
+    locale: string;
+};
+export type ExtractFailedFinding = CheckFindingBase & {
+    code: "extract_failed";
+};
+export type CheckFinding = MissingTranslationFinding | CatalogOutOfSyncFinding | ExtractFailedFinding;
+export type CheckResult = {
+    name: CheckName;
+    passed: boolean;
+    findings: CheckFinding[];
+    summary: string;
+};
+export type CheckContext = {
+    config: LinguiConfigNormalized;
+    catalogs: Catalog[];
+    locales: string[];
+    workersOptions: WorkersOptions;
+    clean: boolean;
+    overwrite: boolean;
+    missingBehavior: MissingBehavior;
+};
+export type CheckRunOptions = {
+    locale?: string[];
+    workersOptions: WorkersOptions;
+    clean?: boolean;
+    overwrite?: boolean;
+    missingBehavior?: MissingBehavior;
+};
+export type CheckDefinition = {
+    name: CheckName;
+    description: string;
+    cli: {
+        options: readonly CheckCliOptionDefinition[];
+        examples: readonly CheckCliExample[];
+    };
+    run: (ctx: CheckContext) => Promise<CheckResult>;
+};
+export declare function finalizeCheckResult(name: CheckName, findings: CheckFinding[], passMessage: string, failMessage: (count: number) => string): CheckResult;

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) {
@@ -14,21 +15,20 @@ export async function compileLocale(catalogs, locale, options, config, doMerge,
             fallbackLocales: config.fallbackLocales,
             sourceLocale: config.sourceLocale,
         });
+        const pseudoLocaleConfig = config.pseudoLocale.find((item) => item.locale === locale);
         if (!options.allowEmpty &&
-            locale !== config.pseudoLocale.locale &&
+            !pseudoLocaleConfig &&
             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();
@@ -53,12 +53,13 @@ async function compileAndWrite(locale, config, options, writePath, messages, log
     const namespace = options.typescript
         ? "ts"
         : options.namespace || config.compileNamespace;
+    const pseudoLocaleConfig = config.pseudoLocale.find((item) => item.locale === locale);
     const { source: compiledCatalog, errors } = createCompiledCatalog(locale, messages, {
         strict: false,
         namespace,
         outputPrefix: options.outputPrefix,
-        pseudoLocale: config.pseudoLocale.locale,
-        pseudoLocaleOptions: config.pseudoLocale.options,
+        pseudoLocale: pseudoLocaleConfig?.locale,
+        pseudoLocaleOptions: pseudoLocaleConfig?.options,
         compilerBabelOptions: config.compilerBabelOptions,
     });
     if (errors.length) {

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/stats.js

@@ -25,8 +25,9 @@ export function printStats(config, catalogs) {
         return a.localeCompare(b);
     })
         .forEach((locale) => {
-        if (locale === config.pseudoLocale.locale)
-            return; // skip pseudo locale
+        // skip pseudo locale
+        if (config.pseudoLocale.some((item) => item.locale === locale))
+            return;
         const catalog = catalogs[locale];
         // catalog is null if no catalog exists on disk and the locale
         // was not extracted due to a `--locale` filter

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);
+    });
+}