@lingui/cli 4.0.0-next.1 → 4.0.0-next.2

package/build/api/formats/po.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = _default;
 exports.deserialize = deserialize;
 exports.serialize = void 0;
 var _dateFns = require("date-fns");
@@ -14,14 +14,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function isGeneratedId(id, message) {
   return id === (0, _generateMessageId.generateMessageId)(message.message, message.context);
 }
-function getCreateHeaders(language = "no") {
+function getCreateHeaders(language) {
   return {
     "POT-Creation-Date": (0, _dateFns.format)(new Date(), "yyyy-MM-dd HH:mmxxxx"),
     "MIME-Version": "1.0",
     "Content-Type": "text/plain; charset=utf-8",
     "Content-Transfer-Encoding": "8bit",
     "X-Generator": "@lingui/cli",
-    Language: language
+    ...(language ? {
+      Language: language
+    } : {})
   };
 }
 const EXPLICIT_ID_FLAG = "explicit-id";
@@ -92,38 +94,32 @@ function validateItem(item) {
     console.warn(`Multiple translations for item with key ${item.msgid} is not supported and it will be ignored.`);
   }
 }
-const po = {
-  catalogExtension: ".po",
-  templateExtension: ".pot",
-  write(filename, catalog, options) {
-    let po;
-    const raw = (0, _utils.readFile)(filename);
-    if (raw) {
-      po = _pofile.default.parse(raw);
-    } else {
-      po = new _pofile.default();
-      po.headers = getCreateHeaders(options.locale);
-      if (options.locale === undefined) {
-        delete po.headers.Language;
+function _default(options = {}) {
+  options = {
+    origins: true,
+    lineNumbers: true,
+    ...options
+  };
+  return {
+    catalogExtension: ".po",
+    templateExtension: ".pot",
+    parse(content) {
+      const po = _pofile.default.parse(content);
+      return deserialize(po.items, validateItem);
+    },
+    serialize(catalog, ctx) {
+      let po;
+      if (ctx.existing) {
+        po = _pofile.default.parse(ctx.existing);
+      } else {
+        po = new _pofile.default();
+        po.headers = getCreateHeaders(ctx.locale)
+        // accessing private property
+        ;
+        po.headerOrder = Object.keys(po.headers);
       }
-      // accessing private property
-      ;
-      po.headerOrder = Object.keys(po.headers);
+      po.items = serialize(catalog, options);
+      return po.toString();
     }
-    po.items = serialize(catalog, options);
-    (0, _utils.writeFileIfChanged)(filename, po.toString());
-  },
-  read(filename) {
-    const raw = (0, _utils.readFile)(filename);
-    if (!raw) {
-      return null;
-    }
-    return this.parse(raw);
-  },
-  parse(raw) {
-    const po = _pofile.default.parse(raw);
-    return deserialize(po.items, validateItem);
-  }
-};
-var _default = po;
-exports.default = _default;
+  };
+}

package/build/api/rethrownError.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RethrownError = void 0;
+class RethrownError extends Error {
+  constructor(message, originalError) {
+    super();
+    this.message = message + " " + originalError.message;
+    this.stack = `Error: ${message} \nOriginal: ` + originalError.stack;
+  }
+}
+exports.RethrownError = RethrownError;

package/build/api/utils.js

@@ -31,7 +31,7 @@ function prettyOrigin(origins) {
 }
 function replacePlaceholders(input, values) {
   return input.replace(/\{([^}]+)}/g, (m, placeholder) => {
-    return values[placeholder] || m;
+    return values[placeholder] ?? m;
   });
 }
 const splitOrigin = origin => {
@@ -41,18 +41,18 @@ const splitOrigin = origin => {
 exports.splitOrigin = splitOrigin;
 const joinOrigin = origin => origin.join(":");
 exports.joinOrigin = joinOrigin;
-function readFile(fileName) {
+async function readFile(fileName) {
   try {
-    return _fs.default.readFileSync(fileName).toString();
+    return (await _fs.default.promises.readFile(fileName)).toString();
   } catch (err) {
     if (err.code != "ENOENT") {
       throw err;
     }
   }
 }
-function mkdirp(dir) {
+async function mkdirp(dir) {
   try {
-    _fs.default.mkdirSync(dir, {
+    await _fs.default.promises.mkdir(dir, {
       recursive: true
     });
   } catch (err) {
@@ -70,18 +70,18 @@ function isDirectory(filePath) {
     }
   }
 }
-function writeFile(fileName, content) {
-  mkdirp(_path.default.dirname(fileName));
-  _fs.default.writeFileSync(fileName, content);
+async function writeFile(fileName, content) {
+  await mkdirp(_path.default.dirname(fileName));
+  await _fs.default.promises.writeFile(fileName, content);
 }
-function writeFileIfChanged(filename, newContent) {
-  const raw = readFile(filename);
+async function writeFileIfChanged(filename, newContent) {
+  const raw = await readFile(filename);
   if (raw) {
     if (newContent !== raw) {
-      writeFile(filename, newContent);
+      await writeFile(filename, newContent);
     }
   } else {
-    writeFile(filename, newContent);
+    await writeFile(filename, newContent);
   }
 }
 function hasYarn() {
@@ -110,6 +110,8 @@ function normalizeRelativePath(sourcePath) {
     // absolute path
     return (0, _normalizePath.default)(sourcePath, false);
   }
+
+  // https://github.com/lingui/js-lingui/issues/809
   const isDir = isDirectory(sourcePath);
   return (0, _normalizePath.default)(_path.default.relative(process.cwd(), sourcePath), false) + (isDir ? "/" : "");
 }

package/build/extract-experimental/buildExternalizeFilter.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildExternalizeFilter = buildExternalizeFilter;
+exports.getPackageJson = getPackageJson;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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);
+  });
+}
+async function getPackageJson(rootDir) {
+  const {
+    default: pkgUp
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require("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 (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(packageJsonPath);
+}

package/build/extract-experimental/bundleSource.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bundleSource = bundleSource;
+var _buildExternalizeFilter = require("./buildExternalizeFilter");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function createExtRegExp(extensions) {
+  return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
+}
+async function bundleSource(config, entryPoints, outDir, rootDir) {
+  const esbuild = await Promise.resolve().then(() => _interopRequireWildcard(require("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.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.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);
+}

package/build/extract-experimental/constants.js

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

package/build/extract-experimental/getEntryPoints.js

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

package/build/extract-experimental/getExperimentalCatalogs.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExperimentalCatalogs = getExperimentalCatalogs;
+var _getEntryPoints = require("./getEntryPoints");
+var _resolveCatalogPath = require("./resolveCatalogPath");
+var _catalog = require("../api/catalog");
+var _resolveTemplatePath = require("./resolveTemplatePath");
+var _api = require("@lingui/cli/api");
+function getExperimentalCatalogs(linguiConfig) {
+  const config = linguiConfig.experimental.extractor;
+  const entryPoints = (0, _getEntryPoints.getEntryPoints)(config.entries);
+  return entryPoints.map(entryPoint => {
+    const catalogPath = (0, _resolveCatalogPath.resolveCatalogPath)(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
+    const format = (0, _api.getFormat)(linguiConfig.format, linguiConfig.formatOptions);
+    const templatePath = (0, _resolveTemplatePath.resolveTemplatePath)(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
+    return new _catalog.Catalog({
+      name: undefined,
+      path: catalogPath,
+      templatePath,
+      include: [],
+      exclude: []
+    }, linguiConfig);
+  });
+}

package/build/extract-experimental/resolveCatalogPath.js

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

package/build/extract-experimental/resolveTemplatePath.js

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

package/build/extract-experimental/writeCatalogs.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeCatalogs = writeCatalogs;
+exports.writeTemplate = writeTemplate;
+var _resolveTemplatePath = require("./resolveTemplatePath");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _resolveCatalogPath = require("./resolveCatalogPath");
+var _mergeCatalog = require("../api/catalog/mergeCatalog");
+var _stats = require("../api/stats");
+var _catalog = require("../api/catalog");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function cleanAndSort(catalog, clean, orderBy) {
+  if (clean) {
+    catalog = (0, _catalog.cleanObsolete)(catalog);
+  }
+  return (0, _catalog.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.resolveCatalogPath)(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
+    const catalog = (0, _mergeCatalog.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.printStats)(linguiConfig, stat).toString()
+  };
+}
+async function writeTemplate(params) {
+  const {
+    entryPoint,
+    outputPattern,
+    linguiConfig,
+    format,
+    clean,
+    messages
+  } = params;
+  const catalogOutput = (0, _resolveTemplatePath.resolveTemplatePath)(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
+  await format.write(catalogOutput, cleanAndSort(messages, clean, linguiConfig.orderBy), undefined);
+  return {
+    statMessage: `${_chalk.default.bold(Object.keys(messages).length)} message(s) extracted`
+  };
+}

package/build/lingui-compile.js

@@ -13,8 +13,10 @@ var _compile = require("./api/compile");
 var _help = require("./api/help");
 var _api = require("./api");
 var _getCatalogs = require("./api/catalog/getCatalogs");
+var _utils = require("./api/utils");
+var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function command(config, options) {
+async function command(config, options) {
   const catalogs = (0, _api.getCatalogs)(config);
 
   // Check config.compile.merge if catalogs for current locale are to be merged into a single compiled file
@@ -24,7 +26,7 @@ function command(config, options) {
   for (const locale of config.locales) {
     for (const catalog of catalogs) {
       const missingMessages = [];
-      const messages = catalog.getTranslations(locale, {
+      const messages = await catalog.getTranslations(locale, {
         fallbackLocales: config.fallbackLocales,
         sourceLocale: config.sourceLocale,
         onMissing: missing => {
@@ -58,7 +60,7 @@ function command(config, options) {
           pseudoLocale: config.pseudoLocale,
           compilerBabelOptions: config.compilerBabelOptions
         });
-        const compiledPath = catalog.writeCompiled(locale, compiledCatalog, namespace);
+        let compiledPath = await catalog.writeCompiled(locale, compiledCatalog, namespace);
         if (options.typescript) {
           const typescriptPath = compiledPath.replace(/\.ts?$/, "") + ".d.ts";
           _fs.default.writeFileSync(typescriptPath, `import { Messages } from '@lingui/core';
@@ -66,6 +68,7 @@ function command(config, options) {
           export { messages };
           `);
         }
+        compiledPath = (0, _utils.normalizeSlashes)(_path.default.relative(config.rootDir, compiledPath));
         options.verbose && console.error(_chalk.default.green(`${locale} ⇒ ${compiledPath}`));
       }
     }
@@ -78,7 +81,8 @@ function command(config, options) {
         pseudoLocale: config.pseudoLocale,
         compilerBabelOptions: config.compilerBabelOptions
       });
-      const compiledPath = compileCatalog.writeCompiled(locale, compiledCatalog, namespace);
+      let compiledPath = await compileCatalog.writeCompiled(locale, compiledCatalog, namespace);
+      compiledPath = (0, _utils.normalizeSlashes)(_path.default.relative(config.rootDir, compiledPath));
       options.verbose && console.log(_chalk.default.green(`${locale} ⇒ ${compiledPath}`));
     }
   }
@@ -99,17 +103,21 @@ if (require.main === module) {
   const config = (0, _conf.getConfig)({
     configPath: options.config
   });
-  const compile = () => 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
-  });
+  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) return compile();
+    if (!options.debounce) compile();
 
     // CLear the previous timer if there is any, and schedule the next
     debounceTimer && clearTimeout(debounceTimer);
@@ -121,7 +129,7 @@ if (require.main === module) {
     console.info(_chalk.default.bold("Initializing Watch Mode..."));
     const catalogs = (0, _api.getCatalogs)(config);
     let paths = [];
-    const catalogExtension = (0, _api.getFormat)(config.format).catalogExtension;
+    const catalogExtension = (0, _api.getFormat)(config.format, config.formatOptions).getCatalogExtension();
     config.locales.forEach(locale => {
       catalogs.forEach(catalog => {
         paths.push(`${catalog.path.replace(/{locale}/g, locale).replace(/{name}/g, "*")}${catalogExtension}`);
@@ -136,10 +144,11 @@ if (require.main === module) {
     };
     watcher.on("ready", () => onReady());
   } else {
-    const results = compile();
-    if (!results) {
-      process.exit(1);
-    }
-    console.log("Done!");
+    compile().then(results => {
+      if (!results) {
+        process.exit(1);
+      }
+      console.log("Done!");
+    });
   }
 }

package/build/lingui-extract-experimental.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = command;
+var _commander = require("commander");
+var _conf = require("@lingui/conf");
+var _path = _interopRequireDefault(require("path"));
+var _os = _interopRequireDefault(require("os"));
+var _formats = require("./api/formats");
+var _promises = _interopRequireDefault(require("fs/promises"));
+var _extractFromFiles = require("./api/catalog/extractFromFiles");
+var _utils = require("./api/utils");
+var _bundleSource = require("./extract-experimental/bundleSource");
+var _writeCatalogs = require("./extract-experimental/writeCatalogs");
+var _getEntryPoints = require("./extract-experimental/getEntryPoints");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function command(linguiConfig, options) {
+  var _linguiConfig$experim;
+  options.verbose && console.log("Extracting messages from source files…");
+  const config = (_linguiConfig$experim = linguiConfig.experimental) === null || _linguiConfig$experim === void 0 ? void 0 : _linguiConfig$experim.extractor;
+  if (!config) {
+    throw new Error("The configuration for experimental extractor is empty. Please read the docs.");
+  }
+  console.log(_chalk.default.yellow(["You have using an experimental feature", "Experimental features are not covered by semver, and may cause unexpected or broken application behavior." + " Use at your own risk.", ""].join("\n")));
+  const tempDir = await _promises.default.mkdtemp(_path.default.join(_os.default.tmpdir(), "js-lingui-extract-"));
+  await _promises.default.rm(tempDir, {
+    recursive: true,
+    force: true
+  });
+  const bundleResult = await (0, _bundleSource.bundleSource)(config, (0, _getEntryPoints.getEntryPoints)(config.entries), tempDir, linguiConfig.rootDir);
+  const stats = [];
+  let commandSuccess = true;
+  const format = (0, _formats.getFormat)(linguiConfig.format, linguiConfig.formatOptions);
+  for (const outFile of Object.keys(bundleResult.metafile.outputs)) {
+    const messages = await (0, _extractFromFiles.extractFromFiles)([outFile], linguiConfig);
+    const {
+      entryPoint
+    } = bundleResult.metafile.outputs[outFile];
+    let output;
+    if (!messages) {
+      commandSuccess = false;
+      continue;
+    }
+    if (options.template) {
+      output = (await (0, _writeCatalogs.writeTemplate)({
+        linguiConfig,
+        clean: options.clean,
+        format,
+        messages,
+        entryPoint,
+        outputPattern: config.output
+      })).statMessage;
+    } else {
+      output = (await (0, _writeCatalogs.writeCatalogs)({
+        locales: options.locales || linguiConfig.locales,
+        linguiConfig,
+        clean: options.clean,
+        format,
+        messages,
+        entryPoint,
+        overwrite: options.overwrite,
+        outputPattern: config.output
+      })).statMessage;
+    }
+    stats.push({
+      entry: (0, _utils.normalizeSlashes)(_path.default.relative(linguiConfig.rootDir, entryPoint)),
+      content: output
+    });
+  }
+
+  // cleanup temp directory
+  await _promises.default.rm(tempDir, {
+    recursive: true,
+    force: true
+  });
+  stats.forEach(({
+    entry,
+    content
+  }) => {
+    console.log([`Catalog statistics for ${entry}:`, content, ""].join("\n"));
+  });
+  return commandSuccess;
+}
+if (require.main === module) {
+  var _options$locale;
+  _commander.program.option("--config <path>", "Path to the config file").option("--template", "Extract to template").option("--overwrite", "Overwrite translations for source locale").option("--clean", "Remove obsolete translations").option("--locale <locale, [...]>", "Only extract the specified locales").option("--verbose", "Verbose output").parse(process.argv);
+  const options = _commander.program.opts();
+  const config = (0, _conf.getConfig)({
+    configPath: options.config
+  });
+  const result = command(config, {
+    verbose: options.verbose || false,
+    template: options.template,
+    locales: (_options$locale = options.locale) === null || _options$locale === void 0 ? void 0 : _options$locale.split(","),
+    overwrite: options.overwrite,
+    clean: options.clean
+  }).then(() => {
+    if (!result) process.exit(1);
+  });
+}

package/build/lingui-extract.js

@@ -49,7 +49,7 @@ async function command(config, options) {
   // If service key is present in configuration, synchronize with cloud translation platform
   if (typeof config.service === "object" && config.service.name && config.service.name.length) {
     const moduleName = config.service.name.charAt(0).toLowerCase() + config.service.name.slice(1);
-    (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))(`./services/${moduleName}`).then(module => module.default(config, options)).catch(err => console.error(`Can't load service module ${moduleName}`, err));
+    await (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))(`./services/${moduleName}`).then(module => module.default(config, options)).catch(err => console.error(`Can't load service module ${moduleName}`, err));
   }
   return commandSuccess;
 }

package/build/lingui.js

@@ -3,4 +3,4 @@
 
 var _commander = require("commander");
 var _package = require("../package.json");
-_commander.program.version(_package.version).command("extract [files...]", "Extracts messages from source files").command("extract-template", "Extracts messages from source files to a .pot template").command("compile", "Compile message catalogs").parse(process.argv);
+_commander.program.version(_package.version).command("extract [files...]", "Extracts messages from source files").command("extract-experimental", "Extracts messages from source files traversing dependency tree").command("extract-template", "Extracts messages from source files to a .pot template").command("compile", "Compile message catalogs").parse(process.argv);