@lingui/cli 6.7.0 → 6.8.0

package/dist/api/catalog/extractFromFiles.d.ts

@@ -1,6 +1,6 @@
 import type { ExtractedMessage, LinguiConfigNormalized } from "@lingui/conf";
 import { ExtractedCatalogType } from "../types.js";
-import type { ExtractWorkerPool } from "../workerPools.js";
-export declare function extractFromFiles(paths: string[], onMessageExtracted: (msg: ExtractedMessage) => void, config: LinguiConfigNormalized): Promise<boolean>;
+import { ExtractWorkerPool } from "../workerPools.js";
+export declare function extractFromFiles(paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType | undefined>;
 export declare function mergeExtractedMessage(next: ExtractedMessage, messages: ExtractedCatalogType, config: LinguiConfigNormalized): void;
-export declare function extractFromFilesWithWorkerPool(workerPool: ExtractWorkerPool, paths: string[], onMessageExtracted: (msg: ExtractedMessage) => void, config: LinguiConfigNormalized): Promise<boolean>;
+export declare function extractFromFilesWithWorkerPool(workerPool: ExtractWorkerPool, paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType | undefined>;

package/dist/api/catalog/extractFromFiles.js

@@ -33,13 +33,18 @@ function mergePlaceholders(prev, next) {
     });
     return res;
 }
-export async function extractFromFiles(paths, onMessageExtracted, config) {
+export async function extractFromFiles(paths, config) {
+    const messages = {};
     let catalogSuccess = true;
     for (const filename of paths) {
-        const fileSuccess = await extract(filename, onMessageExtracted, config);
+        const fileSuccess = await extract(filename, (next) => {
+            mergeExtractedMessage(next, messages, config);
+        }, config);
         catalogSuccess &&= fileSuccess;
     }
-    return catalogSuccess;
+    if (!catalogSuccess)
+        return undefined;
+    return messages;
 }
 export function mergeExtractedMessage(next, messages, config) {
     if (!messages[next.id]) {
@@ -74,12 +79,13 @@ export function mergeExtractedMessage(next, messages, config) {
         placeholders: mergePlaceholders(prev.placeholders, next.placeholders),
     };
 }
-export async function extractFromFilesWithWorkerPool(workerPool, paths, onMessageExtracted, config) {
+export async function extractFromFilesWithWorkerPool(workerPool, paths, config) {
+    const messages = {};
+    let catalogSuccess = true;
     const resolvedConfigPath = config.resolvedConfigPath;
     if (!resolvedConfigPath) {
         throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
     }
-    let catalogSuccess = true;
     const results = await Promise.all(paths.map((filename) => workerPool.run(filename, resolvedConfigPath)));
     results.forEach((result) => {
         if (!result.success) {
@@ -87,9 +93,11 @@ export async function extractFromFilesWithWorkerPool(workerPool, paths, onMessag
         }
         else {
             result.messages.forEach((message) => {
-                onMessageExtracted(message);
+                mergeExtractedMessage(message, messages, config);
             });
         }
     });
-    return catalogSuccess;
+    if (!catalogSuccess)
+        return undefined;
+    return messages;
 }

package/dist/api/catalog/getTranslationsForCatalog.d.ts

@@ -1,16 +1,25 @@
-import { Catalog } from "../catalog.js";
 import { FallbackLocales } from "@lingui/conf";
+import type { AllCatalogsType, CatalogType } from "../types.js";
 export type TranslationMissingEvent = {
     source: string;
     id: string;
 };
+export type MissingBehavior = "resolved" | "catalog";
+export declare function isMissingBehavior(value: string): value is MissingBehavior;
 export type GetTranslationsOptions = {
     sourceLocale: string;
     fallbackLocales: FallbackLocales;
+    missingBehavior?: MissingBehavior;
+    ignoreObsolete?: boolean;
 };
-export declare function getTranslationsForCatalog(catalog: Catalog, locale: string, options: GetTranslationsOptions): Promise<{
+type CatalogTranslationsReader = {
+    readAll(locales: string[]): Promise<AllCatalogsType>;
+    readTemplate(): Promise<CatalogType | undefined>;
+};
+export declare function getTranslationsForCatalog(catalog: CatalogTranslationsReader, locale: string, options: GetTranslationsOptions): Promise<{
     missing: TranslationMissingEvent[];
     messages: {
         [id: string]: string;
     };
 }>;
+export {};

package/dist/api/catalog/getTranslationsForCatalog.js

@@ -1,21 +1,25 @@
 import { getFallbackListForLocale } from "./getFallbackListForLocale.js";
+export function isMissingBehavior(value) {
+    return value === "resolved" || value === "catalog";
+}
 export async function getTranslationsForCatalog(catalog, locale, options) {
-    const locales = new Set([
-        locale,
-        options.sourceLocale,
-        ...getFallbackListForLocale(options.fallbackLocales, locale),
-    ]);
-    const [catalogs, template] = await Promise.all([
+    const fallbackList = getFallbackListForLocale(options.fallbackLocales, locale);
+    const locales = new Set([locale, options.sourceLocale, ...fallbackList]);
+    const [rawCatalogs, rawTemplate] = await Promise.all([
         catalog.readAll(Array.from(locales)),
         catalog.readTemplate(),
     ]);
+    const ignoreObsolete = options.ignoreObsolete ?? false;
+    const catalogs = withoutObsolete(rawCatalogs, ignoreObsolete);
+    const template = withoutObsoleteCatalog(rawTemplate, ignoreObsolete);
     const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
     const input = { ...template, ...sourceLocaleCatalog, ...catalogs[locale] };
     const missing = [];
-    const messages = Object.keys(input).reduce((acc, key) => {
-        acc[key] = getTranslation(catalogs, input[key], locale, key, (event) => {
+    const missingBehavior = options.missingBehavior ?? "resolved";
+    const messages = Object.entries(input).reduce((acc, [key, msg]) => {
+        acc[key] = getTranslation(catalogs, msg, locale, key, options.sourceLocale, fallbackList, ignoreObsolete, missingBehavior, (event) => {
             missing.push(event);
-        }, options);
+        });
         return acc;
     }, {});
     return {
@@ -23,25 +27,47 @@ export async function getTranslationsForCatalog(catalog, locale, options) {
         messages,
     };
 }
-function sourceLocaleFallback(catalog, key) {
-    if (!catalog?.[key]) {
+function isActiveMessage(message, ignoreObsolete) {
+    return Boolean(message && (!ignoreObsolete || !message.obsolete));
+}
+function withoutObsolete(catalogs, ignoreObsolete) {
+    return Object.fromEntries(Object.entries(catalogs).map(([locale, catalog]) => [
+        locale,
+        withoutObsoleteCatalog(catalog, ignoreObsolete),
+    ]));
+}
+function withoutObsoleteCatalog(catalog, ignoreObsolete) {
+    const activeCatalog = {};
+    Object.entries(catalog ?? {}).forEach(([id, message]) => {
+        if (isActiveMessage(message, ignoreObsolete)) {
+            activeCatalog[id] = message;
+        }
+    });
+    return activeCatalog;
+}
+function sourceLocaleFallback(catalog, key, ignoreObsolete) {
+    const message = catalog?.[key];
+    if (!isActiveMessage(message, ignoreObsolete)) {
         return undefined;
     }
-    return catalog[key].translation || catalog[key].message;
+    return message.translation || message.message;
 }
-function getTranslation(catalogs, msg, locale, key, onMissing, options) {
-    const { fallbackLocales, sourceLocale } = options;
-    const getTranslation = (_locale) => {
+function getTranslation(catalogs, msg, locale, key, sourceLocale, fallbackList, ignoreObsolete, missingBehavior, onMissing) {
+    const getCatalogTranslation = (_locale) => {
         const localeCatalog = catalogs[_locale];
-        return localeCatalog?.[key]?.translation;
+        const message = localeCatalog?.[key];
+        if (!isActiveMessage(message, ignoreObsolete)) {
+            return undefined;
+        }
+        return message.translation;
     };
-    const getMultipleFallbacks = (_locale) => {
-        const fL = getFallbackListForLocale(fallbackLocales, _locale);
-        if (!fL.length)
+    const getMultipleFallbacks = () => {
+        if (!fallbackList.length)
             return null;
-        for (const fallbackLocale of fL) {
-            if (catalogs[fallbackLocale] && getTranslation(fallbackLocale)) {
-                return getTranslation(fallbackLocale);
+        for (const fallbackLocale of fallbackList) {
+            const fallbackTranslation = getCatalogTranslation(fallbackLocale);
+            if (catalogs[fallbackLocale] && fallbackTranslation) {
+                return fallbackTranslation;
             }
         }
     };
@@ -51,22 +77,29 @@ function getTranslation(catalogs, msg, locale, key, onMissing, options) {
     // -> template message
     // ** last resort **
     // -> id
+    const catalogTranslation = getCatalogTranslation(locale);
     const translation = 
     // Get translation in target locale
-    getTranslation(locale) ||
+    catalogTranslation ||
         // We search in fallbackLocales as dependent of each locale
-        getMultipleFallbacks(locale) ||
+        getMultipleFallbacks() ||
         (sourceLocale &&
             sourceLocale === locale &&
-            sourceLocaleFallback(catalogs[sourceLocale], key));
-    if (!translation) {
+            sourceLocaleFallback(catalogs[sourceLocale], key, ignoreObsolete));
+    const isMissingTranslation = missingBehavior === "catalog"
+        ? locale !== sourceLocale && !catalogTranslation
+        : !translation;
+    if (isMissingTranslation) {
         onMissing({
             id: key,
-            source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key) || "",
+            source: msg.message ||
+                sourceLocaleFallback(catalogs[sourceLocale], key, ignoreObsolete) ||
+                "",
         });
     }
     return (translation ||
-        (sourceLocale && sourceLocaleFallback(catalogs[sourceLocale], key)) ||
+        (sourceLocale &&
+            sourceLocaleFallback(catalogs[sourceLocale], key, ignoreObsolete)) ||
         // take from template
         msg.message ||
         key);

package/dist/api/catalog/mergeCatalog.js

@@ -20,11 +20,13 @@ export function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options)
         obsoleteKeys = prevKeys;
     }
     // Initialize new catalog with new keys
+    // `translation` is added last, so a message keeps the same key order once it
+    // is merged from the previous catalog on the next extract
     const newMessages = Object.fromEntries(newKeys.map((key) => [
         key,
         {
-            translation: forSourceLocale ? nextCatalog[key].message || key : "",
             ...nextCatalog[key],
+            translation: forSourceLocale ? nextCatalog[key].message || key : "",
         },
     ]));
     // Merge translations from previous catalog

package/dist/api/catalog/translations.d.ts

@@ -0,0 +1,16 @@
+import { Catalog } from "../catalog.js";
+import type { CheckFindingBase } from "../check/types.js";
+import { TranslationMissingEvent } from "./getTranslationsForCatalog.js";
+import type { MissingBehavior } from "./getTranslationsForCatalog.js";
+export type MissingTranslationFinding = CheckFindingBase & {
+    code: "missing_translation";
+    locale: string;
+};
+export declare function getMissingTranslationFindings(catalog: Catalog, locale: string, missingBehavior?: MissingBehavior): Promise<MissingTranslationFinding[]>;
+export declare function getCatalogTranslationsWithMissing(catalog: Catalog, locale: string, missingBehavior?: MissingBehavior): Promise<{
+    messages: {
+        [id: string]: string;
+    };
+    missing: TranslationMissingEvent[];
+}>;
+export declare function createMissingTranslationFinding(catalog: Catalog, locale: string, missing: TranslationMissingEvent): MissingTranslationFinding;

package/dist/api/catalog/translations.js

@@ -0,0 +1,35 @@
+import { toRootRelativePath } from "../utils.js";
+import { getTranslationsForCatalog, } from "./getTranslationsForCatalog.js";
+export async function getMissingTranslationFindings(catalog, locale, missingBehavior = "resolved") {
+    if (catalog.config.pseudoLocale.some((item) => item.locale === locale)) {
+        return [];
+    }
+    const { missing } = await getCatalogTranslationsWithMissing(catalog, locale, missingBehavior);
+    return missing.map((entry) => createMissingTranslationFinding(catalog, locale, entry));
+}
+function createMissingTranslationMessage(messageId, source) {
+    return source || source === messageId
+        ? `${messageId}: (${source})`
+        : messageId;
+}
+export async function getCatalogTranslationsWithMissing(catalog, locale, missingBehavior = "resolved") {
+    const { messages, missing } = await getTranslationsForCatalog(catalog, locale, {
+        fallbackLocales: catalog.config.fallbackLocales,
+        sourceLocale: catalog.config.sourceLocale,
+        missingBehavior,
+        ignoreObsolete: true,
+    });
+    return {
+        messages,
+        missing,
+    };
+}
+export function createMissingTranslationFinding(catalog, locale, missing) {
+    const catalogPath = toRootRelativePath(catalog.config.rootDir, catalog.getFilename(locale));
+    return {
+        code: "missing_translation",
+        locale,
+        catalogPath,
+        message: createMissingTranslationMessage(missing.id, missing.source),
+    };
+}

package/dist/api/catalog.d.ts

@@ -54,7 +54,6 @@ export declare class Catalog {
         files?: string[];
         workerPool?: ExtractWorkerPool;
     }): Promise<ExtractedCatalogType | undefined>;
-    private collectWithExtractors;
     merge(prevCatalogs: AllCatalogsType, nextCatalog: ExtractedCatalogType, options: MergeOptions): {
         [k: string]: CatalogType;
     };

package/dist/api/catalog.js

@@ -4,9 +4,8 @@ import { globSync } from "node:fs";
 import normalize from "normalize-path";
 import { getTranslationsForCatalog, } from "./catalog/getTranslationsForCatalog.js";
 import { mergeCatalog } from "./catalog/mergeCatalog.js";
-import { extractFromFiles, extractFromFilesWithWorkerPool, mergeExtractedMessage, } from "./catalog/extractFromFiles.js";
+import { extractFromFiles, extractFromFilesWithWorkerPool, } from "./catalog/extractFromFiles.js";
 import { isDirectory, makePathRegexSafe, normalizeRelativePath, replacePlaceholders, writeFile, } from "./utils.js";
-import { getConfiguredExtractors, isBatchExtractor, } from "./extractors/index.js";
 const LOCALE = "{locale}";
 const LOCALE_SUFFIX_RE = /\{locale\}.*$/;
 export class Catalog {
@@ -83,63 +82,10 @@ export class Catalog {
             const regex = new RegExp(options.files.join("|"), "i");
             paths = paths.filter((path) => regex.test(normalize(path)));
         }
-        const messages = {};
-        const onMessageExtracted = (next) => {
-            mergeExtractedMessage(next, messages, this.config);
-        };
-        const extractors = getConfiguredExtractors(this.config);
-        // Optimized hot path: if there are no batch extractors defined, skip the more complex logic.
-        if (!extractors.some(isBatchExtractor)) {
-            const success = options.workerPool
-                ? await extractFromFilesWithWorkerPool(options.workerPool, paths, onMessageExtracted, this.config)
-                : await extractFromFiles(paths, onMessageExtracted, this.config);
-            return success ? messages : undefined;
-        }
-        return await this.collectWithExtractors(extractors, paths, onMessageExtracted, messages, options);
-    }
-    async collectWithExtractors(extractors, paths, onMessageExtracted, messages, options) {
-        let remaining = paths;
-        let catalogSuccess = true;
-        for (const extractor of extractors) {
-            if (remaining.length === 0)
-                break;
-            const matched = [];
-            const unmatched = [];
-            for (const f of remaining) {
-                if (extractor.match(f)) {
-                    matched.push(f);
-                }
-                else {
-                    unmatched.push(f);
-                }
-            }
-            if (matched.length === 0)
-                continue;
-            remaining = unmatched;
-            if (isBatchExtractor(extractor)) {
-                try {
-                    await extractor.extractFromFiles(matched, onMessageExtracted, {
-                        linguiConfig: this.config,
-                    });
-                }
-                catch (e) {
-                    console.error(`Extractor failed: ${e.message}`);
-                    console.error(e.stack);
-                    catalogSuccess = false;
-                }
-            }
-            else {
-                const success = options.workerPool
-                    ? await extractFromFilesWithWorkerPool(options.workerPool, matched, onMessageExtracted, this.config)
-                    : await extractFromFiles(matched, onMessageExtracted, this.config);
-                if (!success) {
-                    catalogSuccess = false;
-                }
-            }
+        if (options.workerPool) {
+            return await extractFromFilesWithWorkerPool(options.workerPool, paths, this.config);
         }
-        if (!catalogSuccess)
-            return undefined;
-        return messages;
+        return await extractFromFiles(paths, this.config);
     }
     /*
      *

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

@@ -0,0 +1,8 @@
+import { CheckDefinition, CheckRunOptions } from "./types.js";
+export declare const checkDefinitionsByName: {
+    sync: CheckDefinition;
+    missing: CheckDefinition;
+};
+export declare function getRegisteredChecks(): readonly CheckDefinition[];
+export declare function validateSupportedOptions(check: CheckDefinition, options: CheckRunOptions): void;
+export declare function getCheck(inputCheck: string): CheckDefinition;

package/dist/api/check/index.js

@@ -0,0 +1,39 @@
+import { missingCheck } from "./missing.js";
+import { syncCheck } from "./sync.js";
+import { checkSpecificOptions, } from "./types.js";
+export const checkDefinitionsByName = {
+    sync: syncCheck,
+    missing: missingCheck,
+};
+const registeredChecks = Object.values(checkDefinitionsByName);
+export function getRegisteredChecks() {
+    return registeredChecks;
+}
+function getSupportedOptions(check) {
+    return check.cli.options.map((option) => option.runOption);
+}
+const optionOwnerByOption = new Map(registeredChecks.flatMap((check) => check.cli.options.map((option) => [
+    option.runOption,
+    { checkName: check.name, cliOptionName: option.name },
+])));
+export function validateSupportedOptions(check, options) {
+    checkSpecificOptions.forEach((option) => {
+        if (!options[option] || getSupportedOptions(check).includes(option)) {
+            return;
+        }
+        const owner = optionOwnerByOption.get(option);
+        if (!owner) {
+            throw new Error(`Unsupported check option \`${option}\`.`);
+        }
+        throw new Error(`Option \`--${owner.cliOptionName}\` can only be used with the \`${owner.checkName}\` check.`);
+    });
+}
+function isCheckName(inputCheck) {
+    return Object.prototype.hasOwnProperty.call(checkDefinitionsByName, inputCheck);
+}
+export function getCheck(inputCheck) {
+    if (!isCheckName(inputCheck)) {
+        throw new Error(`Unknown check ${inputCheck}.`);
+    }
+    return checkDefinitionsByName[inputCheck];
+}

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

@@ -0,0 +1,2 @@
+import { CheckDefinition } from "./types.js";
+export declare const missingCheck: CheckDefinition;

package/dist/api/check/missing.js

@@ -0,0 +1,56 @@
+import { getMissingTranslationFindings } from "../catalog/translations.js";
+import { runBounded } from "../runBounded.js";
+import { createMissingWorkerPool } from "../workerPools.js";
+import { finalizeCheckResult } from "./types.js";
+import { getMissingBehaviorDescription } from "../messages.js";
+export const missingCheck = {
+    name: "missing",
+    description: "Verify that message catalogs have no missing translations after fallbackLocales are applied.",
+    cli: {
+        options: [
+            {
+                name: "mode",
+                runOption: "missingBehavior",
+                description: "Missing translation behavior: resolved (after fallbackLocales) or catalog (before fallbackLocales)",
+            },
+        ],
+        examples: [
+            {
+                description: "Check for missing translations after fallbackLocales",
+                command: "check missing",
+            },
+            {
+                description: "Check target catalogs before fallbackLocales",
+                command: "check missing --mode catalog",
+            },
+            {
+                description: "Check missing translations verbosely for a locale",
+                command: "check missing --locale pl --verbose",
+            },
+        ],
+    },
+    async run(ctx) {
+        const tasks = ctx.locales.flatMap((locale) => ctx.catalogs.map((catalog) => ({
+            locale,
+            catalog,
+        })));
+        const resolvedConfigPath = ctx.config.resolvedConfigPath;
+        let workerPool;
+        if (ctx.workersOptions.poolSize > 0 && resolvedConfigPath) {
+            workerPool = createMissingWorkerPool(ctx.workersOptions);
+        }
+        let findings;
+        try {
+            findings = (await runBounded(tasks, ctx.workersOptions.poolSize, async ({ locale, catalog }) => workerPool
+                ? workerPool.run(catalog.path, locale, ctx.missingBehavior, resolvedConfigPath)
+                : getMissingTranslationFindings(catalog, locale, ctx.missingBehavior))).flat();
+        }
+        finally {
+            if (workerPool) {
+                await workerPool.destroy();
+            }
+        }
+        const missingBehaviorDescription = getMissingBehaviorDescription(ctx.missingBehavior);
+        return finalizeCheckResult("missing", findings, `No missing translations found ${missingBehaviorDescription}.`, (count) => `Found ${count} missing translation(s) ${missingBehaviorDescription}.`);
+    },
+};

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

@@ -0,0 +1,2 @@
+import { CheckDefinition } from "./types.js";
+export declare const syncCheck: CheckDefinition;

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;