@lingui/cli 4.0.0-next.4 → 4.0.0-next.6

package/dist/api/utils.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRelativePath = exports.normalizeSlashes = exports.makeInstall = exports.hasYarn = exports.writeFileIfChanged = exports.writeFile = exports.isDirectory = exports.readFile = exports.joinOrigin = exports.splitOrigin = exports.replacePlaceholders = exports.prettyOrigin = exports.PATHSEP = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
+exports.PATHSEP = "/"; // force posix everywhere
+function prettyOrigin(origins) {
+    try {
+        return origins.map((origin) => origin.join(":")).join(", ");
+    }
+    catch (e) {
+        return "";
+    }
+}
+exports.prettyOrigin = prettyOrigin;
+function replacePlaceholders(input, values) {
+    return input.replace(/\{([^}]+)}/g, (m, placeholder) => {
+        var _a;
+        return (_a = values[placeholder]) !== null && _a !== void 0 ? _a : m;
+    });
+}
+exports.replacePlaceholders = replacePlaceholders;
+const splitOrigin = (origin) => {
+    const [file, line] = origin.split(":");
+    return [file, line ? Number(line) : null];
+};
+exports.splitOrigin = splitOrigin;
+const joinOrigin = (origin) => origin.join(":");
+exports.joinOrigin = joinOrigin;
+async function readFile(fileName) {
+    try {
+        return (await fs_1.default.promises.readFile(fileName)).toString();
+    }
+    catch (err) {
+        if (err.code != "ENOENT") {
+            throw err;
+        }
+    }
+}
+exports.readFile = readFile;
+async function mkdirp(dir) {
+    try {
+        await fs_1.default.promises.mkdir(dir, {
+            recursive: true,
+        });
+    }
+    catch (err) {
+        if (err.code != "EEXIST") {
+            throw err;
+        }
+    }
+}
+function isDirectory(filePath) {
+    try {
+        return fs_1.default.lstatSync(filePath).isDirectory();
+    }
+    catch (err) {
+        if (err.code != "ENOENT") {
+            throw err;
+        }
+    }
+}
+exports.isDirectory = isDirectory;
+async function writeFile(fileName, content) {
+    await mkdirp(path_1.default.dirname(fileName));
+    await fs_1.default.promises.writeFile(fileName, content);
+}
+exports.writeFile = writeFile;
+async function writeFileIfChanged(filename, newContent) {
+    const raw = await readFile(filename);
+    if (raw) {
+        if (newContent !== raw) {
+            await writeFile(filename, newContent);
+        }
+    }
+    else {
+        await writeFile(filename, newContent);
+    }
+}
+exports.writeFileIfChanged = writeFileIfChanged;
+function hasYarn() {
+    return fs_1.default.existsSync(path_1.default.resolve("yarn.lock"));
+}
+exports.hasYarn = hasYarn;
+function makeInstall(packageName, dev = false) {
+    const withYarn = hasYarn();
+    return withYarn
+        ? `yarn add ${dev ? "--dev " : ""}${packageName}`
+        : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
+}
+exports.makeInstall = makeInstall;
+/**
+ * Normalize Windows backslashes in path so they look always as posix
+ */
+function normalizeSlashes(path) {
+    return path.replace("\\", "/");
+}
+exports.normalizeSlashes = normalizeSlashes;
+/**
+ * Remove ./ at the beginning: ./relative  => relative
+ *                             relative    => relative
+ * Preserve directories:       ./relative/ => relative/
+ * Preserve absolute paths:    /absolute/path => /absolute/path
+ */
+function normalizeRelativePath(sourcePath) {
+    if (path_1.default.isAbsolute(sourcePath)) {
+        // absolute path
+        return (0, normalize_path_1.default)(sourcePath, false);
+    }
+    // https://github.com/lingui/js-lingui/issues/809
+    const isDir = isDirectory(sourcePath);
+    return ((0, normalize_path_1.default)(path_1.default.relative(process.cwd(), sourcePath), false) +
+        (isDir ? "/" : ""));
+}
+exports.normalizeRelativePath = normalizeRelativePath;

package/dist/extract-experimental/buildExternalizeFilter.d.ts

@@ -0,0 +1,13 @@
+type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+};
+export declare function buildExternalizeFilter({ includeDeps, excludeDeps, packageJson, }: {
+    includeDeps: string[];
+    excludeDeps: string[];
+    packageJson: PackageJson;
+}): (id: string) => boolean;
+export declare function getPackageJson(rootDir: string): Promise<PackageJson>;
+export {};

package/dist/extract-experimental/buildExternalizeFilter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = exports.buildExternalizeFilter = void 0;
+function createPackageRegExp(packageName) {
+    return new RegExp("^" + packageName + "(?:\\/.+)?");
+}
+function packages(packages, includeDeps) {
+    return Object.keys(packages || {})
+        .filter((packageName) => {
+        return !includeDeps.some((incl) => packageName.startsWith(incl));
+    })
+        .map(createPackageRegExp);
+}
+function buildExternalizeFilter({ includeDeps, excludeDeps, packageJson, }) {
+    const external = [
+        ...packages(packageJson.dependencies, includeDeps),
+        ...packages(packageJson.devDependencies, includeDeps),
+        ...packages(packageJson.peerDependencies, includeDeps),
+        ...packages(packageJson.optionalDependencies, includeDeps),
+        ...excludeDeps.map(createPackageRegExp),
+    ];
+    return (id) => external.some((regExp) => {
+        return regExp.test(id);
+    });
+}
+exports.buildExternalizeFilter = buildExternalizeFilter;
+async function getPackageJson(rootDir) {
+    const { default: pkgUp } = await import("pkg-up");
+    const packageJsonPath = await pkgUp({
+        cwd: rootDir,
+    });
+    if (!packageJsonPath) {
+        throw new Error("We could not able to find your package.json file. " +
+            "Check that `rootDir` is pointing to the folder with package.json");
+    }
+    return await import(packageJsonPath);
+}
+exports.getPackageJson = getPackageJson;

package/dist/extract-experimental/bundleSource.d.ts

@@ -0,0 +1,2 @@
+import { ExperimentalExtractorOptions } from "@lingui/conf";
+export declare function bundleSource(config: ExperimentalExtractorOptions, entryPoints: string[], outDir: string, rootDir: string): Promise<import("esbuild").BuildResult<any>>;

package/dist/extract-experimental/bundleSource.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleSource = void 0;
+const buildExternalizeFilter_1 = require("./buildExternalizeFilter");
+function createExtRegExp(extensions) {
+    return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
+}
+async function bundleSource(config, entryPoints, outDir, rootDir) {
+    const esbuild = await import("esbuild");
+    const excludeExtensions = config.excludeExtensions || [
+        "ico",
+        "pot",
+        "xliff",
+        "woff2",
+        "woff",
+        "eot",
+        "gif",
+        "otf",
+        "ttf",
+        "mp4",
+        "svg",
+        "png",
+        "css",
+        "sass",
+        "less",
+        "jpg",
+    ];
+    const packageJson = await (0, buildExternalizeFilter_1.getPackageJson)(rootDir);
+    const esbuildOptions = {
+        entryPoints: entryPoints,
+        outExtension: { ".js": ".jsx" },
+        jsx: "preserve",
+        bundle: true,
+        platform: "node",
+        target: ["esnext"],
+        format: "esm",
+        splitting: false,
+        treeShaking: true,
+        outdir: outDir,
+        sourcemap: "inline",
+        sourceRoot: outDir,
+        sourcesContent: false,
+        outbase: rootDir,
+        metafile: true,
+        plugins: [
+            {
+                name: "externalize-deps",
+                setup(build) {
+                    const isExternal = (0, buildExternalizeFilter_1.buildExternalizeFilter)({
+                        includeDeps: config.includeDeps || [],
+                        excludeDeps: config.excludeDeps || [],
+                        packageJson,
+                    });
+                    // externalize bare imports
+                    build.onResolve({ filter: /^[^.].*/ }, async ({ path: id }) => {
+                        if (isExternal(id)) {
+                            return {
+                                external: true,
+                            };
+                        }
+                    });
+                },
+            },
+            {
+                name: "externalize-files",
+                setup(build) {
+                    build.onResolve({ filter: createExtRegExp(excludeExtensions) }, () => ({
+                        external: true,
+                    }));
+                },
+            },
+        ],
+    };
+    return await esbuild.build(config.resolveEsbuildOptions
+        ? config.resolveEsbuildOptions(esbuildOptions)
+        : esbuildOptions);
+}
+exports.bundleSource = bundleSource;

package/dist/extract-experimental/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ENTRY_NAME_PH = "{entryName}";
+export declare const DEFAULT_TEMPLATE_NAME = "messages";

package/dist/extract-experimental/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEMPLATE_NAME = exports.ENTRY_NAME_PH = void 0;
+exports.ENTRY_NAME_PH = "{entryName}";
+exports.DEFAULT_TEMPLATE_NAME = "messages";

package/dist/extract-experimental/getEntryPoints.d.ts

@@ -0,0 +1 @@
+export declare function getEntryPoints(entries: string[]): string[];

package/dist/extract-experimental/getEntryPoints.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryPoints = void 0;
+const glob_1 = __importDefault(require("glob"));
+function getEntryPoints(entries) {
+    const patterns = entries.length > 1 ? `{${entries.join(",")}}` : entries[0];
+    return glob_1.default.sync(patterns, { mark: true });
+}
+exports.getEntryPoints = getEntryPoints;

package/dist/extract-experimental/getExperimentalCatalogs.d.ts

@@ -0,0 +1,3 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { Catalog } from "../api/catalog";
+export declare function getExperimentalCatalogs(linguiConfig: LinguiConfigNormalized): Promise<Catalog[]>;

package/dist/extract-experimental/getExperimentalCatalogs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExperimentalCatalogs = void 0;
+const getEntryPoints_1 = require("./getEntryPoints");
+const resolveCatalogPath_1 = require("./resolveCatalogPath");
+const catalog_1 = require("../api/catalog");
+const resolveTemplatePath_1 = require("./resolveTemplatePath");
+const formats_1 = require("../api/formats");
+async function getExperimentalCatalogs(linguiConfig) {
+    const config = linguiConfig.experimental.extractor;
+    const entryPoints = (0, getEntryPoints_1.getEntryPoints)(config.entries);
+    const format = await (0, formats_1.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+    return entryPoints.map((entryPoint) => {
+        const catalogPath = (0, resolveCatalogPath_1.resolveCatalogPath)(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
+        const templatePath = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
+        return new catalog_1.Catalog({
+            name: undefined,
+            path: catalogPath,
+            templatePath,
+            include: [],
+            exclude: [],
+            format,
+        }, linguiConfig);
+    });
+}
+exports.getExperimentalCatalogs = getExperimentalCatalogs;

package/dist/extract-experimental/resolveCatalogPath.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCatalogPath(configOutput: string, entryPath: string, rootDir: string, locale: string, extension: string): string;
+export declare function getEntryName(entryPath: string): string;

package/dist/extract-experimental/resolveCatalogPath.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryName = exports.resolveCatalogPath = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../api/utils");
+function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
+    const entryName = getEntryName(entryPath);
+    const entryDir = path_1.default.relative(rootDir, path_1.default.dirname(entryPath));
+    return path_1.default.normalize((0, utils_1.replacePlaceholders)(configOutput, {
+        entryName,
+        entryDir,
+        locale,
+    }) + extension);
+}
+exports.resolveCatalogPath = resolveCatalogPath;
+function getEntryName(entryPath) {
+    const parsedPath = path_1.default.parse(entryPath);
+    return parsedPath.name.replace(parsedPath.ext, "");
+}
+exports.getEntryName = getEntryName;

package/dist/extract-experimental/resolveTemplatePath.d.ts

@@ -0,0 +1 @@
+export declare function resolveTemplatePath(entryPoint: string, output: string, rootDir: string, catalogExtension: string): string;

package/dist/extract-experimental/resolveTemplatePath.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplatePath = void 0;
+const resolveCatalogPath_1 = require("./resolveCatalogPath");
+const constants_1 = require("./constants");
+function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
+    let templateName;
+    if (output.includes(constants_1.ENTRY_NAME_PH)) {
+        templateName = constants_1.DEFAULT_TEMPLATE_NAME;
+    }
+    else {
+        templateName = (0, resolveCatalogPath_1.getEntryName)(entryPoint);
+    }
+    return (0, resolveCatalogPath_1.resolveCatalogPath)(output, entryPoint, rootDir, templateName, catalogExtension);
+}
+exports.resolveTemplatePath = resolveTemplatePath;

package/dist/extract-experimental/writeCatalogs.d.ts

@@ -0,0 +1,21 @@
+import { ExtractedCatalogType } from "../api";
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { FormatterWrapper } from "../api/formats";
+type ExtractTemplateParams = {
+    format: FormatterWrapper;
+    clean: boolean;
+    entryPoint: string;
+    outputPattern: string;
+    linguiConfig: LinguiConfigNormalized;
+    messages: ExtractedCatalogType;
+};
+type ExtractParams = ExtractTemplateParams & {
+    locales: string[];
+    overwrite: boolean;
+};
+type ExtractStats = {
+    statMessage: string;
+};
+export declare function writeCatalogs(params: ExtractParams): Promise<ExtractStats>;
+export declare function writeTemplate(params: ExtractTemplateParams): Promise<ExtractStats>;
+export {};

package/dist/extract-experimental/writeCatalogs.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeTemplate = exports.writeCatalogs = void 0;
+const resolveTemplatePath_1 = require("./resolveTemplatePath");
+const chalk_1 = __importDefault(require("chalk"));
+const resolveCatalogPath_1 = require("./resolveCatalogPath");
+const mergeCatalog_1 = require("../api/catalog/mergeCatalog");
+const stats_1 = require("../api/stats");
+const catalog_1 = require("../api/catalog");
+function cleanAndSort(catalog, clean, orderBy) {
+    if (clean) {
+        catalog = (0, catalog_1.cleanObsolete)(catalog);
+    }
+    return (0, catalog_1.order)(orderBy)(catalog);
+}
+async function writeCatalogs(params) {
+    const { entryPoint, outputPattern, linguiConfig, locales, overwrite, format, clean, messages, } = params;
+    const stat = {};
+    for (const locale of locales) {
+        const catalogOutput = (0, resolveCatalogPath_1.resolveCatalogPath)(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
+        const catalog = (0, mergeCatalog_1.mergeCatalog)(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, { overwrite });
+        await format.write(catalogOutput, cleanAndSort(catalog, clean, linguiConfig.orderBy), locale);
+        stat[locale] = catalog;
+    }
+    return {
+        statMessage: (0, stats_1.printStats)(linguiConfig, stat).toString(),
+    };
+}
+exports.writeCatalogs = writeCatalogs;
+async function writeTemplate(params) {
+    const { entryPoint, outputPattern, linguiConfig, format, clean, messages } = params;
+    const catalogOutput = (0, resolveTemplatePath_1.resolveTemplatePath)(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
+    await format.write(catalogOutput, cleanAndSort(messages, clean, linguiConfig.orderBy), undefined);
+    return {
+        statMessage: `${chalk_1.default.bold(Object.keys(messages).length)} message(s) extracted`,
+    };
+}
+exports.writeTemplate = writeTemplate;

package/dist/lingui-compile.d.ts

@@ -0,0 +1,9 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+export type CliCompileOptions = {
+    verbose?: boolean;
+    allowEmpty?: boolean;
+    typescript?: boolean;
+    watch?: boolean;
+    namespace?: string;
+};
+export declare function command(config: LinguiConfigNormalized, options: CliCompileOptions): Promise<boolean>;

package/dist/lingui-compile.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const conf_1 = require("@lingui/conf");
+const compile_1 = require("./api/compile");
+const help_1 = require("./api/help");
+const api_1 = require("./api");
+const getCatalogs_1 = require("./api/catalog/getCatalogs");
+const utils_1 = require("./api/utils");
+const path_1 = __importDefault(require("path"));
+async function command(config, options) {
+    const catalogs = await (0, api_1.getCatalogs)(config);
+    // Check config.compile.merge if catalogs for current locale are to be merged into a single compiled file
+    const doMerge = !!config.catalogsMergePath;
+    let mergedCatalogs = {};
+    console.log("Compiling message catalogs…");
+    for (const locale of config.locales) {
+        for (const catalog of catalogs) {
+            const missingMessages = [];
+            const messages = await catalog.getTranslations(locale, {
+                fallbackLocales: config.fallbackLocales,
+                sourceLocale: config.sourceLocale,
+                onMissing: (missing) => {
+                    missingMessages.push(missing);
+                },
+            });
+            if (!options.allowEmpty && missingMessages.length > 0) {
+                console.error(chalk_1.default.red(`Error: Failed to compile catalog for locale ${chalk_1.default.bold(locale)}!`));
+                if (options.verbose) {
+                    console.error(chalk_1.default.red("Missing translations:"));
+                    missingMessages.forEach((missing) => {
+                        const source = missing.source || missing.source === missing.id
+                            ? `: (${missing.source})`
+                            : "";
+                        console.error(`${missing.id}${source}`);
+                    });
+                }
+                else {
+                    console.error(chalk_1.default.red(`Missing ${missingMessages.length} translation(s)`));
+                }
+                console.error();
+                return false;
+            }
+            if (doMerge) {
+                mergedCatalogs = Object.assign(Object.assign({}, mergedCatalogs), messages);
+            }
+            else {
+                const namespace = options.typescript
+                    ? "ts"
+                    : options.namespace || config.compileNamespace;
+                const compiledCatalog = (0, compile_1.createCompiledCatalog)(locale, messages, {
+                    strict: false,
+                    namespace,
+                    pseudoLocale: config.pseudoLocale,
+                    compilerBabelOptions: config.compilerBabelOptions,
+                });
+                let compiledPath = await catalog.writeCompiled(locale, compiledCatalog, namespace);
+                if (options.typescript) {
+                    const typescriptPath = compiledPath.replace(/\.ts?$/, "") + ".d.ts";
+                    fs_1.default.writeFileSync(typescriptPath, `import { Messages } from '@lingui/core';
+          declare const messages: Messages;
+          export { messages };
+          `);
+                }
+                compiledPath = (0, utils_1.normalizeSlashes)(path_1.default.relative(config.rootDir, compiledPath));
+                options.verbose &&
+                    console.error(chalk_1.default.green(`${locale} ⇒ ${compiledPath}`));
+            }
+        }
+        if (doMerge) {
+            const compileCatalog = await (0, getCatalogs_1.getCatalogForMerge)(config);
+            const namespace = options.namespace || config.compileNamespace;
+            const compiledCatalog = (0, compile_1.createCompiledCatalog)(locale, mergedCatalogs, {
+                strict: false,
+                namespace: namespace,
+                pseudoLocale: config.pseudoLocale,
+                compilerBabelOptions: config.compilerBabelOptions,
+            });
+            let compiledPath = await compileCatalog.writeCompiled(locale, compiledCatalog, namespace);
+            compiledPath = (0, utils_1.normalizeSlashes)(path_1.default.relative(config.rootDir, compiledPath));
+            options.verbose && console.log(chalk_1.default.green(`${locale} ⇒ ${compiledPath}`));
+        }
+    }
+    return true;
+}
+exports.command = command;
+if (require.main === module) {
+    commander_1.program
+        .description("Add compile message catalogs and add language data (plurals) to compiled bundle.")
+        .option("--config <path>", "Path to the config file")
+        .option("--strict", "Disable defaults for missing translations")
+        .option("--verbose", "Verbose output")
+        .option("--typescript", "Create Typescript definition for compiled bundle")
+        .option("--namespace <namespace>", "Specify namespace for compiled bundle. Ex: cjs(default) -> module.exports, es -> export, window.test -> window.test")
+        .option("--watch", "Enables Watch Mode")
+        .option("--debounce <delay>", "Debounces compilation for given amount of milliseconds")
+        .on("--help", function () {
+        console.log("\n  Examples:\n");
+        console.log("    # Compile translations and use defaults or message IDs for missing translations");
+        console.log(`    $ ${(0, help_1.helpRun)("compile")}`);
+        console.log("");
+        console.log("    # Compile translations but fail when there are missing");
+        console.log("    # translations (don't replace missing translations with");
+        console.log("    # default messages or message IDs)");
+        console.log(`    $ ${(0, help_1.helpRun)("compile --strict")}`);
+    })
+        .parse(process.argv);
+    const options = commander_1.program.opts();
+    const config = (0, conf_1.getConfig)({ configPath: options.config });
+    let previousRun = Promise.resolve(true);
+    const compile = () => {
+        previousRun = previousRun.then(() => command(config, {
+            verbose: options.watch || options.verbose || false,
+            allowEmpty: !options.strict,
+            typescript: options.typescript || config.compileNamespace === "ts" || false,
+            namespace: options.namespace, // we want this to be undefined if user does not specify so default can be used
+        }));
+        return previousRun;
+    };
+    let debounceTimer;
+    const dispatchCompile = () => {
+        // Skip debouncing if not enabled
+        if (!options.debounce)
+            compile();
+        // CLear the previous timer if there is any, and schedule the next
+        debounceTimer && clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => compile(), options.debounce);
+    };
+    // Check if Watch Mode is enabled
+    if (options.watch) {
+        console.info(chalk_1.default.bold("Initializing Watch Mode..."));
+        (async function initWatch() {
+            const format = await (0, api_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+            const catalogs = await (0, api_1.getCatalogs)(config);
+            const paths = [];
+            config.locales.forEach((locale) => {
+                catalogs.forEach((catalog) => {
+                    paths.push(`${catalog.path
+                        .replace(/{locale}/g, locale)
+                        .replace(/{name}/g, "*")}${format.getCatalogExtension()}`);
+                });
+            });
+            const watcher = chokidar_1.default.watch(paths, {
+                persistent: true,
+            });
+            const onReady = () => {
+                console.info(chalk_1.default.green.bold("Watcher is ready!"));
+                watcher
+                    .on("add", () => dispatchCompile())
+                    .on("change", () => dispatchCompile());
+            };
+            watcher.on("ready", () => onReady());
+        })();
+    }
+    else {
+        compile().then((results) => {
+            if (!results) {
+                process.exit(1);
+            }
+            console.log("Done!");
+        });
+    }
+}

package/dist/lingui-extract-experimental.d.ts

@@ -0,0 +1,10 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+export type CliExtractTemplateOptions = {
+    verbose: boolean;
+    files?: string[];
+    template?: boolean;
+    locales?: string[];
+    overwrite?: boolean;
+    clean?: boolean;
+};
+export default function command(linguiConfig: LinguiConfigNormalized, options: Partial<CliExtractTemplateOptions>): Promise<boolean>;