@lingui/cli 5.4.1 → 5.5.0

package/dist/api/ProgramExit.d.ts

@@ -0,0 +1,3 @@
+export declare class ProgramExit extends Error {
+    constructor();
+}

package/dist/api/ProgramExit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgramExit = void 0;
+class ProgramExit extends Error {
+    constructor() {
+        super();
+        this.name = "ProgramExit";
+    }
+}
+exports.ProgramExit = ProgramExit;

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

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

package/dist/api/catalog/extractFromFiles.js

@@ -4,12 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFromFiles = extractFromFiles;
+exports.mergeExtractedMessage = mergeExtractedMessage;
+exports.extractFromFilesWithWorkerPool = extractFromFilesWithWorkerPool;
 const picocolors_1 = __importDefault(require("picocolors"));
 const path_1 = __importDefault(require("path"));
 const extractors_1 = __importDefault(require("../extractors"));
 const utils_1 = require("../utils");
 function mergePlaceholders(prev, next) {
     const res = Object.assign({}, prev);
+    // Handle case where next is null or undefined
+    if (!next)
+        return res;
     Object.entries(next).forEach(([key, value]) => {
         if (!res[key]) {
             res[key] = [];
@@ -24,37 +29,59 @@ function mergePlaceholders(prev, next) {
 async function extractFromFiles(paths, config) {
     const messages = {};
     let catalogSuccess = true;
-    await Promise.all(paths.map(async (filename) => {
+    for (const filename of paths) {
         const fileSuccess = await (0, extractors_1.default)(filename, (next) => {
-            var _a;
-            if (!messages[next.id]) {
-                messages[next.id] = {
-                    message: next.message,
-                    context: next.context,
-                    placeholders: {},
-                    comments: [],
-                    origin: [],
-                };
-            }
-            const prev = messages[next.id];
-            // there might be a case when filename was not mapped from sourcemaps
-            const filename = next.origin[0]
-                ? path_1.default.relative(config.rootDir, next.origin[0]).replace(/\\/g, "/")
-                : "";
-            const origin = [filename, next.origin[1]];
-            if (prev.message && next.message && prev.message !== next.message) {
-                throw new Error(`Encountered different default translations for message ${picocolors_1.default.yellow(next.id)}` +
-                    `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)(prev.origin))} ${prev.message}` +
-                    `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)([origin]))} ${next.message}`);
-            }
-            messages[next.id] = Object.assign(Object.assign({}, prev), { message: (_a = prev.message) !== null && _a !== void 0 ? _a : next.message, comments: next.comment
-                    ? [...prev.comments, next.comment].sort()
-                    : prev.comments, origin: [...prev.origin, [filename, next.origin[1]]].sort((a, b) => a[0].localeCompare(b[0])), placeholders: mergePlaceholders(prev.placeholders, next.placeholders) });
-        }, config, {
-            extractors: config.extractors,
-        });
+            mergeExtractedMessage(next, messages, config);
+        }, config);
         catalogSuccess && (catalogSuccess = fileSuccess);
-    }));
+    }
+    if (!catalogSuccess)
+        return undefined;
+    return messages;
+}
+function mergeExtractedMessage(next, messages, config) {
+    var _a;
+    if (!messages[next.id]) {
+        messages[next.id] = {
+            message: next.message,
+            context: next.context,
+            placeholders: {},
+            comments: [],
+            origin: [],
+        };
+    }
+    const prev = messages[next.id];
+    // there might be a case when filename was not mapped from sourcemaps
+    const filename = next.origin[0]
+        ? path_1.default.relative(config.rootDir, next.origin[0]).replace(/\\/g, "/")
+        : "";
+    const origin = [filename, next.origin[1]];
+    if (prev.message && next.message && prev.message !== next.message) {
+        throw new Error(`Encountered different default translations for message ${picocolors_1.default.yellow(next.id)}` +
+            `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)(prev.origin))} ${prev.message}` +
+            `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)([origin]))} ${next.message}`);
+    }
+    messages[next.id] = Object.assign(Object.assign({}, prev), { message: (_a = prev.message) !== null && _a !== void 0 ? _a : next.message, comments: next.comment
+            ? [...prev.comments, next.comment].sort()
+            : prev.comments, origin: [...prev.origin, [filename, next.origin[1]]].sort((a, b) => a[0].localeCompare(b[0])), placeholders: mergePlaceholders(prev.placeholders, next.placeholders) });
+}
+async function extractFromFilesWithWorkerPool(workerPool, paths, config) {
+    const messages = {};
+    let catalogSuccess = true;
+    if (!config.resolvedConfigPath) {
+        throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
+    }
+    await Promise.all(paths.map((filename) => workerPool.queue(async (worker) => {
+        const result = await worker(filename, config.resolvedConfigPath);
+        if (!result.success) {
+            catalogSuccess = false;
+        }
+        else {
+            result.messages.forEach((message) => {
+                mergeExtractedMessage(message, messages, config);
+            });
+        }
+    })));
     if (!catalogSuccess)
         return undefined;
     return messages;

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

@@ -7,7 +7,7 @@ export declare function getCatalogs(config: LinguiConfigNormalized): Promise<Cat
 /**
  * Create catalog for merged messages.
  */
-export declare function getCatalogForMerge(config: LinguiConfigNormalized): Promise<Catalog>;
+export declare function getMergedCatalogPath(config: LinguiConfigNormalized): Promise<string>;
 export declare function getCatalogForFile(file: string, catalogs: Catalog[]): {
     locale: string;
     catalog: Catalog;

package/dist/api/catalog/getCatalogs.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCatalogs = getCatalogs;
-exports.getCatalogForMerge = getCatalogForMerge;
+exports.getMergedCatalogPath = getMergedCatalogPath;
 exports.getCatalogForFile = getCatalogForFile;
 const glob_1 = require("glob");
 const path_1 = __importDefault(require("path"));
@@ -78,16 +78,10 @@ const ensureArray = (value) => {
 /**
  * Create catalog for merged messages.
  */
-async function getCatalogForMerge(config) {
+async function getMergedCatalogPath(config) {
     const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
     validateCatalogPath(config.catalogsMergePath, format.getCatalogExtension());
-    return new catalog_1.Catalog({
-        name: getCatalogName(config.catalogsMergePath),
-        path: (0, utils_1.normalizeRelativePath)(config.catalogsMergePath),
-        include: [],
-        exclude: [],
-        format,
-    }, config);
+    return (0, utils_1.normalizeRelativePath)(config.catalogsMergePath);
 }
 function getCatalogForFile(file, catalogs) {
     for (const catalog of catalogs) {
@@ -108,6 +102,9 @@ function getCatalogForFile(file, catalogs) {
  *  Validate that `catalogPath` doesn't end with trailing slash
  */
 function validateCatalogPath(path, extension) {
+    if (!path.includes(LOCALE_PH)) {
+        throw new Error(`Invalid catalog path: ${LOCALE_PH} variable is missing`);
+    }
     if (!path.endsWith(utils_1.PATHSEP)) {
         return;
     }

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

@@ -7,8 +7,10 @@ export type TranslationMissingEvent = {
 export type GetTranslationsOptions = {
     sourceLocale: string;
     fallbackLocales: FallbackLocales;
-    onMissing?: (message: TranslationMissingEvent) => void;
 };
 export declare function getTranslationsForCatalog(catalog: Catalog, locale: string, options: GetTranslationsOptions): Promise<{
-    [id: string]: string;
+    missing: TranslationMissingEvent[];
+    messages: {
+        [id: string]: string;
+    };
 }>;

package/dist/api/catalog/getTranslationsForCatalog.js

@@ -3,16 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTranslationsForCatalog = getTranslationsForCatalog;
 const getFallbackListForLocale_1 = require("./getFallbackListForLocale");
 async function getTranslationsForCatalog(catalog, locale, options) {
+    const locales = new Set([
+        locale,
+        options.sourceLocale,
+        ...(0, getFallbackListForLocale_1.getFallbackListForLocale)(options.fallbackLocales, locale),
+    ]);
     const [catalogs, template] = await Promise.all([
-        catalog.readAll(),
+        catalog.readAll(Array.from(locales)),
         catalog.readTemplate(),
     ]);
     const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
     const input = Object.assign(Object.assign(Object.assign({}, template), sourceLocaleCatalog), catalogs[locale]);
-    return Object.keys(input).reduce((acc, key) => {
-        acc[key] = getTranslation(catalogs, input[key], locale, key, options);
+    const missing = [];
+    const messages = Object.keys(input).reduce((acc, key) => {
+        acc[key] = getTranslation(catalogs, input[key], locale, key, (event) => {
+            missing.push(event);
+        }, options);
         return acc;
     }, {});
+    return {
+        missing,
+        messages,
+    };
 }
 function sourceLocaleFallback(catalog, key) {
     if (!(catalog === null || catalog === void 0 ? void 0 : catalog[key])) {
@@ -20,8 +32,8 @@ function sourceLocaleFallback(catalog, key) {
     }
     return catalog[key].translation || catalog[key].message;
 }
-function getTranslation(catalogs, msg, locale, key, options) {
-    const { fallbackLocales, sourceLocale, onMissing } = options;
+function getTranslation(catalogs, msg, locale, key, onMissing, options) {
+    const { fallbackLocales, sourceLocale } = options;
     const getTranslation = (_locale) => {
         var _a;
         const localeCatalog = catalogs[_locale];
@@ -52,7 +64,7 @@ function getTranslation(catalogs, msg, locale, key, options) {
             sourceLocale === locale &&
             sourceLocaleFallback(catalogs[sourceLocale], key));
     if (!translation) {
-        onMissing === null || onMissing === void 0 ? void 0 : onMissing({
+        onMissing({
             id: key,
             source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key),
         });

package/dist/api/catalog.d.ts

@@ -1,15 +1,21 @@
 import { LinguiConfigNormalized, OrderBy } from "@lingui/conf";
 import { FormatterWrapper } from "./formats";
-import { CliExtractOptions } from "../lingui-extract";
-import { CliExtractTemplateOptions } from "../lingui-extract-template";
 import { CompiledCatalogNamespace } from "./compile";
-import { GetTranslationsOptions, TranslationMissingEvent } from "./catalog/getTranslationsForCatalog";
+import { GetTranslationsOptions } from "./catalog/getTranslationsForCatalog";
 import { AllCatalogsType, CatalogType, ExtractedCatalogType } from "./types";
-export type MakeOptions = CliExtractOptions & {
+import { ExtractWorkerPool } from "./extractWorkerPool";
+export type MakeOptions = {
+    files?: string[];
+    clean: boolean;
+    overwrite: boolean;
+    locale: string[];
     orderBy?: OrderBy;
+    workerPool?: ExtractWorkerPool;
 };
-export type MakeTemplateOptions = CliExtractTemplateOptions & {
+export type MakeTemplateOptions = {
+    files?: string[];
     orderBy?: OrderBy;
+    workerPool?: ExtractWorkerPool;
 };
 export type MergeOptions = {
     overwrite?: boolean;
@@ -40,21 +46,21 @@ export declare class Catalog {
      */
     collect(options?: {
         files?: string[];
+        workerPool?: ExtractWorkerPool;
     }): Promise<ExtractedCatalogType | undefined>;
     merge(prevCatalogs: AllCatalogsType, nextCatalog: ExtractedCatalogType, options: MergeOptions): {
         [k: string]: CatalogType;
     };
-    getTranslations(locale: string, options: Omit<GetTranslationsOptions, "onMissing">): Promise<{
-        missing: TranslationMissingEvent[];
+    getTranslations(locale: string, options: GetTranslationsOptions): Promise<{
+        missing: import("./catalog/getTranslationsForCatalog").TranslationMissingEvent[];
         messages: {
             [id: string]: string;
         };
     }>;
     write(locale: string, messages: CatalogType): Promise<[created: boolean, filename: string]>;
     writeTemplate(messages: CatalogType): Promise<void>;
-    writeCompiled(locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
     read(locale: string): Promise<CatalogType>;
-    readAll(): Promise<AllCatalogsType>;
+    readAll(locales?: string[]): Promise<AllCatalogsType>;
     readTemplate(): Promise<CatalogType>;
     get sourcePaths(): string[];
     get localeDir(): string;
@@ -62,4 +68,5 @@ export declare class Catalog {
 }
 export declare function cleanObsolete<T extends ExtractedCatalogType>(messages: T): T;
 export declare function order<T extends ExtractedCatalogType>(by: OrderBy, catalog: T): T;
+export declare function writeCompiled(path: string, locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
 export declare function orderByMessage<T extends ExtractedCatalogType>(messages: T): T;

package/dist/api/catalog.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Catalog = void 0;
 exports.cleanObsolete = cleanObsolete;
 exports.order = order;
+exports.writeCompiled = writeCompiled;
 exports.orderByMessage = orderByMessage;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -35,7 +36,7 @@ class Catalog {
     }
     async make(options) {
         const [nextCatalog, prevCatalogs] = await Promise.all([
-            this.collect({ files: options.files }),
+            this.collect({ files: options.files, workerPool: options.workerPool }),
             this.readAll(),
         ]);
         if (!nextCatalog)
@@ -57,7 +58,10 @@ class Catalog {
         return sortedCatalogs;
     }
     async makeTemplate(options) {
-        const catalog = await this.collect({ files: options.files });
+        const catalog = await this.collect({
+            files: options.files,
+            workerPool: options.workerPool,
+        });
         if (!catalog)
             return false;
         const sorted = order(options.orderBy, catalog);
@@ -74,6 +78,9 @@ class Catalog {
             const regex = new RegExp(options.files.join("|"), "i");
             paths = paths.filter((path) => regex.test((0, normalize_path_1.default)(path)));
         }
+        if (options.workerPool) {
+            return await (0, extractFromFiles_1.extractFromFilesWithWorkerPool)(options.workerPool, paths, this.config);
+        }
         return await (0, extractFromFiles_1.extractFromFiles)(paths, this.config);
     }
     /*
@@ -103,14 +110,7 @@ class Catalog {
         ]));
     }
     async getTranslations(locale, options) {
-        const missing = [];
-        const messages = await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(this, locale, Object.assign(Object.assign({}, options), { onMissing: (event) => {
-                missing.push(event);
-            } }));
-        return {
-            missing,
-            messages,
-        };
+        return await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(this, locale, options);
     }
     async write(locale, messages) {
         const filename = this.getFilename(locale);
@@ -122,29 +122,12 @@ class Catalog {
         const filename = this.templateFile;
         await this.format.write(filename, messages, undefined);
     }
-    async writeCompiled(locale, compiledCatalog, namespace) {
-        let ext;
-        switch (namespace) {
-            case "es":
-                ext = "mjs";
-                break;
-            case "ts":
-            case "json":
-                ext = namespace;
-                break;
-            default:
-                ext = "js";
-        }
-        const filename = `${(0, utils_1.replacePlaceholders)(this.path, { locale })}.${ext}`;
-        await (0, utils_1.writeFile)(filename, compiledCatalog);
-        return filename;
-    }
     async read(locale) {
         return await this.format.read(this.getFilename(locale), locale);
     }
-    async readAll() {
+    async readAll(locales = this.locales) {
         const res = {};
-        await Promise.all(this.locales.map(async (locale) => (res[locale] = await this.read(locale))));
+        await Promise.all(locales.map(async (locale) => (res[locale] = await this.read(locale))));
         // statement above will save locales in object in undetermined order
         // resort here to have keys order the same as in locales definition
         return this.locales.reduce((acc, locale) => {
@@ -240,6 +223,23 @@ function orderByOrigin(messages) {
         return acc;
     }, {});
 }
+async function writeCompiled(path, locale, compiledCatalog, namespace) {
+    let ext;
+    switch (namespace) {
+        case "es":
+            ext = "mjs";
+            break;
+        case "ts":
+        case "json":
+            ext = namespace;
+            break;
+        default:
+            ext = "js";
+    }
+    const filename = `${(0, utils_1.replacePlaceholders)(path, { locale })}.${ext}`;
+    await (0, utils_1.writeFile)(filename, compiledCatalog);
+    return filename;
+}
 function orderByMessage(messages) {
     // hardcoded en-US locale to have consistent sorting
     // @see https://github.com/lingui/js-lingui/pull/1808

package/dist/api/compile/compileLocale.d.ts

@@ -0,0 +1,5 @@
+import { Catalog } from "../catalog";
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { CliCompileOptions } from "../../lingui-compile";
+import { Logger } from "../logger";
+export declare function compileLocale(catalogs: Catalog[], locale: string, options: CliCompileOptions, config: LinguiConfigNormalized, doMerge: boolean, logger: Logger): Promise<void>;

package/dist/api/compile/compileLocale.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileLocale = compileLocale;
+const catalog_1 = require("../catalog");
+const picocolors_1 = __importDefault(require("picocolors"));
+const getCatalogs_1 = require("../catalog/getCatalogs");
+const ProgramExit_1 = require("../ProgramExit");
+const compile_1 = require("../compile");
+const normalize_path_1 = __importDefault(require("normalize-path"));
+const path_1 = __importDefault(require("path"));
+const messages_1 = require("../messages");
+const getTranslationsForCatalog_1 = require("../catalog/getTranslationsForCatalog");
+async function compileLocale(catalogs, locale, options, config, doMerge, logger) {
+    let mergedCatalogs = {};
+    for (const catalog of catalogs) {
+        const { messages, missing: missingMessages } = await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(catalog, locale, {
+            fallbackLocales: config.fallbackLocales,
+            sourceLocale: config.sourceLocale,
+        });
+        if (!options.allowEmpty &&
+            locale !== config.pseudoLocale &&
+            missingMessages.length > 0) {
+            logger.error(picocolors_1.default.red(`Error: Failed to compile catalog for locale ${picocolors_1.default.bold(locale)}!`));
+            if (options.verbose) {
+                logger.error(picocolors_1.default.red("Missing translations:"));
+                missingMessages.forEach((missing) => {
+                    const source = missing.source || missing.source === missing.id
+                        ? `: (${missing.source})`
+                        : "";
+                    logger.error(`${missing.id}${source}`);
+                });
+            }
+            else {
+                logger.error(picocolors_1.default.red(`Missing ${missingMessages.length} translation(s)`));
+            }
+            logger.error();
+            throw new ProgramExit_1.ProgramExit();
+        }
+        if (doMerge) {
+            mergedCatalogs = Object.assign(Object.assign({}, mergedCatalogs), messages);
+        }
+        else {
+            if (!(await compileAndWrite(locale, config, options, catalog.path, messages, logger))) {
+                throw new ProgramExit_1.ProgramExit();
+            }
+        }
+    }
+    if (doMerge) {
+        const result = await compileAndWrite(locale, config, options, await (0, getCatalogs_1.getMergedCatalogPath)(config), mergedCatalogs, logger);
+        if (!result) {
+            throw new ProgramExit_1.ProgramExit();
+        }
+    }
+}
+async function compileAndWrite(locale, config, options, writePath, messages, logger) {
+    const namespace = options.typescript
+        ? "ts"
+        : options.namespace || config.compileNamespace;
+    const { source: compiledCatalog, errors } = (0, compile_1.createCompiledCatalog)(locale, messages, {
+        strict: false,
+        namespace,
+        pseudoLocale: config.pseudoLocale,
+        compilerBabelOptions: config.compilerBabelOptions,
+    });
+    if (errors.length) {
+        let message = (0, messages_1.createCompilationErrorMessage)(locale, errors);
+        if (options.failOnCompileError) {
+            message += `These errors fail command execution because \`--strict\` option passed`;
+            logger.error(picocolors_1.default.red(message));
+            return false;
+        }
+        else {
+            message += `You can fail command execution on these errors by passing \`--strict\` option`;
+            logger.error(picocolors_1.default.red(message));
+        }
+    }
+    let compiledPath = await (0, catalog_1.writeCompiled)(writePath, locale, compiledCatalog, namespace);
+    compiledPath = (0, normalize_path_1.default)(path_1.default.relative(config.rootDir, compiledPath));
+    options.verbose && logger.error(picocolors_1.default.green(`${locale} ⇒ ${compiledPath}`));
+    return true;
+}

package/dist/api/extractWorkerPool.d.ts

@@ -0,0 +1 @@
+export type ExtractWorkerPool = ReturnType<typeof createExtractWorkerPool>;

package/dist/api/extractWorkerPool.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtractWorkerPool = createExtractWorkerPool;
+const threads_1 = require("threads");
+/** @internal */
+function createExtractWorkerPool(opts) {
+    return (0, threads_1.Pool)(() => (0, threads_1.spawn)(new threads_1.Worker("../workers/extractWorker")), { size: opts.poolSize });
+}

package/dist/api/extractors/babel.js

@@ -120,6 +120,7 @@ function getBabelParserOptions(filename, parserOptions) {
         "importAttributes", // stage3
         "explicitResourceManagement", // stage3,
         "decoratorAutoAccessors", // stage3,
+        "deferredImportEvaluation", // stage3
     ];
     if ([/\.ts$/, /\.mts$/, /\.cts$/, /\.tsx$/].some((r) => filename.match(r))) {
         parserPlugins.push("typescript");

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

@@ -1,6 +1,2 @@
-import { ExtractedMessage, ExtractorType, LinguiConfigNormalized } from "@lingui/conf";
-type ExtractOptions = {
-    extractors?: ExtractorType[];
-};
-export default function extract(filename: string, onMessageExtracted: (msg: ExtractedMessage) => void, linguiConfig: LinguiConfigNormalized, options: ExtractOptions): Promise<boolean>;
-export {};
+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

@@ -7,9 +7,9 @@ exports.default = extract;
 const promises_1 = __importDefault(require("fs/promises"));
 const babel_1 = __importDefault(require("./babel"));
 const DEFAULT_EXTRACTORS = [babel_1.default];
-async function extract(filename, onMessageExtracted, linguiConfig, options) {
+async function extract(filename, onMessageExtracted, linguiConfig) {
     var _a;
-    const extractorsToExtract = (_a = options.extractors) !== null && _a !== void 0 ? _a : DEFAULT_EXTRACTORS;
+    const extractorsToExtract = (_a = linguiConfig.extractors) !== null && _a !== void 0 ? _a : DEFAULT_EXTRACTORS;
     for (const ext of extractorsToExtract) {
         if (!ext.match(filename))
             continue;

package/dist/api/logger.d.ts

@@ -0,0 +1,3 @@
+export type Logger = {
+    error: (msg?: string) => void;
+};

package/dist/api/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/resolveWorkersOptions.d.ts

@@ -0,0 +1,6 @@
+export type WorkersOptions = {
+    poolSize: number;
+};
+export declare function resolveWorkersOptions(opts: {
+    workers?: number | string;
+}): WorkersOptions;

package/dist/api/resolveWorkersOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkersOptions = resolveWorkersOptions;
+const node_os_1 = __importDefault(require("node:os"));
+function resolveWorkersOptions(opts) {
+    const cores = node_os_1.default.availableParallelism();
+    if (Number(opts.workers) <= 1 || cores === 1) {
+        return { poolSize: 0 };
+    }
+    if (!opts.workers) {
+        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) };
+}

package/dist/api/stats.js

@@ -25,7 +25,15 @@ function printStats(config, catalogs) {
             compact: true,
         },
     });
-    Object.keys(catalogs).forEach((locale) => {
+    Object.keys(catalogs)
+        .sort((a, b) => {
+        if (a === config.sourceLocale && b !== config.sourceLocale)
+            return -1;
+        if (b === config.sourceLocale && a !== config.sourceLocale)
+            return 1;
+        return a.localeCompare(b);
+    })
+        .forEach((locale) => {
         if (locale === config.pseudoLocale)
             return; // skip pseudo locale
         const catalog = catalogs[locale];

package/dist/api/workerLogger.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from "./logger";
+export type SerializedLogs = {
+    errors: string;
+};
+export declare class WorkerLogger implements Logger {
+    private errors;
+    error(msg?: string): void;
+    flush(): SerializedLogs;
+}

package/dist/api/workerLogger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerLogger = void 0;
+class WorkerLogger {
+    constructor() {
+        this.errors = [];
+    }
+    error(msg) {
+        this.errors.push(msg);
+    }
+    flush() {
+        const errors = this.errors.join("\n");
+        this.errors = [];
+        return {
+            errors,
+        };
+    }
+}
+exports.WorkerLogger = WorkerLogger;