@lingui/cli 6.6.0 → 6.8.0

package/README.md

@@ -4,22 +4,43 @@
 
 # @lingui/cli
 
-> lingui command line library for manipulating message catalogues
+> Lingui CLI: extracts i18n messages from source code into catalogs and compiles the translated catalogs for the runtime
 
-`@lingui/cli` is part of [LinguiJS][linguijs]. See the [documentation][documentation] for all information, tutorials and examples.
+`@lingui/cli` is part of [Lingui][documentation]. Lingui is a lightweight, open-source internationalization (i18n) library for JavaScript and TypeScript. It brings compile-time macros and a CLI for message extraction to React, React Native, Vue, SolidJS, Astro, Svelte, and Node.js.
 
-## Installation & Usage
+The `lingui` command reads `lingui.config.js` (or `.ts`) from the project root: the source locale, the target locales and where the catalogs live. The [installation guide][installation] shows the minimal file and the [configuration reference][conf] lists every option.
 
-See the [reference][reference] documentation.
+## Installation
+
+```sh
+npm install --save-dev @lingui/cli
+```
+
+## Usage
+
+- `lingui extract` finds the messages in the source, merges them into one catalog per locale, keeps existing translations and marks removed messages as obsolete.
+- `lingui compile` compiles the translated catalogs into JavaScript modules for the runtime and reports messages with invalid ICU syntax.
+- `lingui extract-template` writes a single `.pot` template with the source messages, for translation platforms that create the locale files themselves.
+- `lingui extract-experimental` follows the imports from each entry point instead of a glob, so a multi-page app gets one catalog per page.
+
+Extraction parses JavaScript and TypeScript out of the box; Vue single-file components need [`@lingui/extractor-vue`][extractor-vue]. Catalogs are PO files by default, with [other formats][catalog-formats] available as separate packages. To let the bundler compile catalogs instead of running `lingui compile`, use [`@lingui/vite-plugin`][vite-plugin], [`@lingui/loader`][loader] or [`@lingui/metro-transformer`][metro-transformer].
+
+See the [CLI reference][reference] for all commands and options.
 
 ## License
 
-This package is licensed under [MIT][license] license.
+This package is licensed under the [MIT][license] license.
 
 [license]: https://github.com/lingui/js-lingui/blob/main/LICENSE
-[linguijs]: https://github.com/lingui/js-lingui
 [documentation]: https://lingui.dev
+[installation]: https://lingui.dev/installation
+[conf]: https://lingui.dev/ref/conf
 [reference]: https://lingui.dev/ref/cli
+[catalog-formats]: https://lingui.dev/ref/catalog-formats
+[extractor-vue]: https://lingui.dev/ref/extractor-vue
+[vite-plugin]: https://lingui.dev/ref/vite-plugin
+[loader]: https://lingui.dev/ref/loader
+[metro-transformer]: https://lingui.dev/ref/metro-transformer
 [package]: https://www.npmjs.com/package/@lingui/cli
 [badge-downloads]: https://img.shields.io/npm/dw/@lingui/cli.svg
 [badge-version]: https://img.shields.io/npm/v/@lingui/cli.svg

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);
     }
     /*
      *
@@ -273,12 +219,15 @@ export function order(by, catalog) {
         return acc;
     }, {});
 }
+// hardcoded en-US locale to have consistent sorting
+// @see https://github.com/lingui/js-lingui/pull/1808
+const collator = new Intl.Collator("en-US");
 /**
  * Object keys are in the same order as they were created
  * https://stackoverflow.com/a/31102605/1535540
  */
 const orderByMessageId = (a, b) => {
-    return a.messageId.localeCompare(b.messageId);
+    return collator.compare(a.messageId, b.messageId);
 };
 const orderByOrigin = (a, b) => {
     if (!a.entry.origin || !b.entry.origin) {
@@ -323,9 +272,6 @@ export async function writeCompiled(path, locale, compiledCatalog, namespace) {
     await writeFile(filename, compiledCatalog);
     return filename;
 }
-// hardcoded en-US locale to have consistent sorting
-// @see https://github.com/lingui/js-lingui/pull/1808
-const collator = new Intl.Collator("en-US");
 export const orderByMessage = (a, b) => {
     const aMsg = a.entry.message || "";
     const bMsg = b.entry.message || "";

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;