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

package/build/api/catalog/getCatalogs.js

@@ -12,6 +12,7 @@ var _catalog = require("../catalog");
 var _utils = require("../utils");
 var _micromatch = _interopRequireDefault(require("micromatch"));
 var _formats = require("../formats");
+var _getExperimentalCatalogs = require("../../extract-experimental/getExperimentalCatalogs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const NAME_PH = "{name}";
 const LOCALE_PH = "{locale}";
@@ -19,11 +20,13 @@ const LOCALE_PH = "{locale}";
 /**
  * Parse `config.catalogs` and return a list of configured Catalog instances.
  */
-function getCatalogs(config) {
+async function getCatalogs(config) {
+  var _config$experimental, _config$experimental$;
   const catalogsConfig = config.catalogs;
   const catalogs = [];
+  const format = await (0, _formats.getFormat)(config.format, config.formatOptions, config.sourceLocale);
   catalogsConfig.forEach(catalog => {
-    validateCatalogPath(catalog.path, config);
+    validateCatalogPath(catalog.path, format.getCatalogExtension());
     const include = ensureArray(catalog.include).map(_utils.normalizeRelativePath);
     const exclude = ensureArray(catalog.exclude).map(_utils.normalizeRelativePath);
 
@@ -38,7 +41,8 @@ function getCatalogs(config) {
         name: getCatalogName(catalog.path),
         path: (0, _utils.normalizeRelativePath)(catalog.path),
         include,
-        exclude
+        exclude,
+        format
       }, config));
       return;
     }
@@ -61,10 +65,14 @@ function getCatalogs(config) {
         })),
         exclude: exclude.map(path => (0, _utils.replacePlaceholders)(path, {
           name
-        }))
+        })),
+        format
       }, config));
     });
   });
+  if ((_config$experimental = config.experimental) !== null && _config$experimental !== void 0 && (_config$experimental$ = _config$experimental.extractor) !== null && _config$experimental$ !== void 0 && _config$experimental$.entries.length) {
+    catalogs.push(...(await (0, _getExperimentalCatalogs.getExperimentalCatalogs)(config)));
+  }
   return catalogs;
 }
 
@@ -79,18 +87,20 @@ const ensureArray = value => {
 /**
  * Create catalog for merged messages.
  */
-function getCatalogForMerge(config) {
-  validateCatalogPath(config.catalogsMergePath, config);
+async function getCatalogForMerge(config) {
+  const format = await (0, _formats.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+  validateCatalogPath(config.catalogsMergePath, format.getCatalogExtension());
   return new _catalog.Catalog({
     name: getCatalogName(config.catalogsMergePath),
     path: (0, _utils.normalizeRelativePath)(config.catalogsMergePath),
     include: [],
-    exclude: []
+    exclude: [],
+    format
   }, config);
 }
 function getCatalogForFile(file, catalogs) {
   for (const catalog of catalogs) {
-    const catalogFile = `${catalog.path}${catalog.format.catalogExtension}`;
+    const catalogFile = `${catalog.path}${catalog.format.getCatalogExtension()}`;
     const catalogGlob = (0, _utils.replacePlaceholders)(catalogFile, {
       locale: "*"
     });
@@ -108,14 +118,13 @@ function getCatalogForFile(file, catalogs) {
 /**
  *  Validate that `catalogPath` doesn't end with trailing slash
  */
-function validateCatalogPath(path, config) {
+function validateCatalogPath(path, extension) {
   if (!path.endsWith(_utils.PATHSEP)) {
     return;
   }
-  const extension = (0, _formats.getFormat)(config.format).catalogExtension;
   const correctPath = path.slice(0, -1);
   const examplePath = (0, _utils.replacePlaceholders)(correctPath, {
-    locale: (config.locales || [])[0] || "en"
+    locale: "en"
   }) + extension;
   throw new Error(
   // prettier-ignore

package/build/api/catalog/getTranslationsForCatalog.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getTranslationsForCatalog = getTranslationsForCatalog;
-function getTranslationsForCatalog(catalog, locale, options) {
-  const catalogs = catalog.readAll();
-  const template = catalog.readTemplate() || {};
+async function getTranslationsForCatalog(catalog, locale, options) {
+  const catalogs = await catalog.readAll();
+  const template = (await catalog.readTemplate()) || {};
   const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
   const input = {
     ...template,

package/build/api/catalog.js

@@ -5,14 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.cleanObsolete = exports.Catalog = void 0;
 exports.order = order;
-exports.orderByMessageId = orderByMessageId;
-exports.orderByOrigin = orderByOrigin;
+exports.orderByMessage = orderByMessage;
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
 var R = _interopRequireWildcard(require("ramda"));
 var _glob = _interopRequireDefault(require("glob"));
 var _normalizePath = _interopRequireDefault(require("normalize-path"));
-var _formats = require("./formats");
 var _getTranslationsForCatalog = require("./catalog/getTranslationsForCatalog");
 var _mergeCatalog = require("./catalog/mergeCatalog");
 var _extractFromFiles = require("./catalog/extractFromFiles");
@@ -28,6 +26,7 @@ class Catalog {
     path,
     include,
     templatePath,
+    format,
     exclude = []
   }, config) {
     this.config = config;
@@ -35,15 +34,15 @@ class Catalog {
     this.path = (0, _utils.normalizeRelativePath)(path);
     this.include = include.map(_utils.normalizeRelativePath);
     this.exclude = [this.localeDir, ...exclude.map(_utils.normalizeRelativePath)];
-    this.format = (0, _formats.getFormat)(config.format);
-    this.templateFile = templatePath || getTemplatePath(this.format, this.path);
+    this.format = format;
+    this.templateFile = templatePath || getTemplatePath(this.format.getTemplateExtension(), this.path);
   }
   async make(options) {
     const nextCatalog = await this.collect({
       files: options.files
     });
     if (!nextCatalog) return false;
-    const prevCatalogs = this.readAll();
+    const prevCatalogs = await this.readAll();
     const catalogs = this.merge(prevCatalogs, nextCatalog, {
       overwrite: options.overwrite,
       files: options.files
@@ -56,11 +55,8 @@ class Catalog {
     // Sort messages
     order(options.orderBy)));
     const sortedCatalogs = cleanAndSort(catalogs);
-    if (options.locale) {
-      this.write(options.locale, sortedCatalogs[options.locale]);
-    } else {
-      this.writeAll(sortedCatalogs);
-    }
+    const locales = options.locale ? [options.locale] : this.locales;
+    await Promise.all(locales.map(locale => this.write(locale, sortedCatalogs[locale])));
     return sortedCatalogs;
   }
   async makeTemplate(options) {
@@ -69,7 +65,7 @@ class Catalog {
     });
     if (!catalog) return false;
     const sorted = order(options.orderBy)(catalog);
-    this.writeTemplate(sorted);
+    await this.writeTemplate(sorted);
     return sorted;
   }
 
@@ -111,33 +107,22 @@ class Catalog {
       return (0, _mergeCatalog.mergeCatalog)(prevCatalog, nextCatalog, this.config.sourceLocale === locale, options);
     }, prevCatalogs);
   }
-  getTranslations(locale, options) {
-    return (0, _getTranslationsForCatalog.getTranslationsForCatalog)(this, locale, options);
+  async getTranslations(locale, options) {
+    return await (0, _getTranslationsForCatalog.getTranslationsForCatalog)(this, locale, options);
   }
-  write(locale, messages) {
+  async write(locale, messages) {
     const filename = (0, _utils.replacePlaceholders)(this.path, {
       locale
-    }) + this.format.catalogExtension;
+    }) + this.format.getCatalogExtension();
     const created = !_fs.default.existsSync(filename);
-    const options = {
-      ...this.config.formatOptions,
-      locale
-    };
-    this.format.write(filename, messages, options);
+    await this.format.write(filename, messages, locale);
     return [created, filename];
   }
-  writeAll(catalogs) {
-    this.locales.forEach(locale => this.write(locale, catalogs[locale]));
-  }
-  writeTemplate(messages) {
+  async writeTemplate(messages) {
     const filename = this.templateFile;
-    const options = {
-      ...this.config.formatOptions,
-      locale: undefined
-    };
-    this.format.write(filename, messages, options);
+    await this.format.write(filename, messages, undefined);
   }
-  writeCompiled(locale, compiledCatalog, namespace) {
+  async writeCompiled(locale, compiledCatalog, namespace) {
     let ext;
     if (namespace === "es") {
       ext = "mjs";
@@ -149,23 +134,29 @@ class Catalog {
     const filename = `${(0, _utils.replacePlaceholders)(this.path, {
       locale
     })}.${ext}`;
-    (0, _utils.writeFile)(filename, compiledCatalog);
+    await (0, _utils.writeFile)(filename, compiledCatalog);
     return filename;
   }
-  read(locale) {
+  async read(locale) {
     const filename = (0, _utils.replacePlaceholders)(this.path, {
       locale
-    }) + this.format.catalogExtension;
-    return this.format.read(filename);
+    }) + this.format.getCatalogExtension();
+    return await this.format.read(filename, locale);
   }
-  readAll() {
-    return R.mergeAll(this.locales.map(locale => ({
-      [locale]: this.read(locale)
-    })));
-  }
-  readTemplate() {
+  async readAll() {
+    const res = {};
+    await Promise.all(this.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) => {
+      acc[locale] = res[locale];
+      return acc;
+    }, {});
+  }
+  async readTemplate() {
     const filename = this.templateFile;
-    return this.format.read(filename);
+    return await this.format.read(filename, undefined);
   }
   get sourcePaths() {
     const includeGlobs = this.include.map(includePath => {
@@ -194,8 +185,7 @@ class Catalog {
   }
 }
 exports.Catalog = Catalog;
-function getTemplatePath(format, path) {
-  const ext = format.templateExtension || format.catalogExtension;
+function getTemplatePath(ext, path) {
   return path.replace(LOCALE_SUFFIX_RE, "messages" + ext);
 }
 const cleanObsolete = R.filter(message => !message.obsolete);
@@ -203,6 +193,7 @@ exports.cleanObsolete = cleanObsolete;
 function order(by) {
   return {
     messageId: orderByMessageId,
+    message: orderByMessage,
     origin: orderByOrigin
   }[by];
 }
@@ -240,4 +231,15 @@ function orderByOrigin(messages) {
     acc[key] = messages[key];
     return acc;
   }, {});
+}
+function orderByMessage(messages) {
+  return Object.keys(messages).sort((a, b) => {
+    const aMsg = messages[a].message || "";
+    const bMsg = messages[b].message || "";
+    return aMsg.localeCompare(bMsg);
+  }).reduce((acc, key) => {
+    ;
+    acc[key] = messages[key];
+    return acc;
+  }, {});
 }

package/build/api/compile.js

@@ -26,6 +26,11 @@ function createCompiledCatalog(locale, messages, options) {
     obj[key] = compile(translation, shouldPseudolocalize);
     return obj;
   }, {});
+  if (namespace === "json") {
+    return JSON.stringify({
+      messages: compiledMessages
+    });
+  }
   const ast = buildExportStatement(
   //build JSON.parse(<compiledMessages>) statement
   t.callExpression(t.memberExpression(t.identifier("JSON"), t.identifier("parse")), [t.stringLiteral(JSON.stringify(compiledMessages))]), namespace);

package/build/api/extractors/babel.js

@@ -18,15 +18,21 @@ const extractor = {
   },
   async extract(filename, code, onMessageExtracted, ctx) {
     const parserOptions = ctx.linguiConfig.extractorParserOptions;
-    const parserPlugins = [
+
     // https://babeljs.io/docs/en/babel-parser#latest-ecmascript-features
-    ["decorators", {
-      decoratorsBeforeExport: (parserOptions === null || parserOptions === void 0 ? void 0 : parserOptions.decoratorsBeforeExport) || true
-    }]];
+    const parserPlugins = [];
     if ([/\.ts$/, /\.mts$/, /\.cts$/, /\.tsx$/].some(r => filename.match(r))) {
       parserPlugins.push("typescript");
-    } else if (parserOptions !== null && parserOptions !== void 0 && parserOptions.flow) {
-      parserPlugins.push("flow");
+      if (parserOptions.tsExperimentalDecorators) {
+        parserPlugins.push("decorators-legacy");
+      } else {
+        parserPlugins.push("decorators");
+      }
+    } else {
+      parserPlugins.push("decorators");
+      if (parserOptions !== null && parserOptions !== void 0 && parserOptions.flow) {
+        parserPlugins.push("flow");
+      }
     }
     if ([/\.jsx$/, /\.tsx$/].some(r => filename.match(r))) {
       parserPlugins.push("jsx");

package/build/api/formats/formatterWrapper.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormatterWrapper = void 0;
+var _utils = require("../utils");
+var _rethrownError = require("../rethrownError");
+class FormatterWrapper {
+  constructor(f, sourceLocale) {
+    this.f = f;
+    this.sourceLocale = sourceLocale;
+  }
+  getCatalogExtension() {
+    return this.f.catalogExtension;
+  }
+  getTemplateExtension() {
+    return this.f.templateExtension || this.f.catalogExtension;
+  }
+  async write(filename, catalog, locale) {
+    const content = await this.f.serialize(catalog, {
+      locale,
+      sourceLocale: this.sourceLocale,
+      existing: await (0, _utils.readFile)(filename),
+      filename
+    });
+    await (0, _utils.writeFileIfChanged)(filename, content);
+  }
+  async read(filename, locale) {
+    const content = await (0, _utils.readFile)(filename);
+    if (!content) {
+      return null;
+    }
+    try {
+      return this.f.parse(content, {
+        locale,
+        sourceLocale: this.sourceLocale,
+        filename
+      });
+    } catch (e) {
+      throw new _rethrownError.RethrownError(`Cannot read ${filename}`, e);
+    }
+  }
+}
+exports.FormatterWrapper = FormatterWrapper;

package/build/api/formats/index.js

@@ -3,29 +3,55 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "FormatterWrapper", {
+  enumerable: true,
+  get: function () {
+    return _formatterWrapper.FormatterWrapper;
+  }
+});
 exports.getFormat = getFormat;
-var _csv = _interopRequireDefault(require("./csv"));
-var _lingui = _interopRequireDefault(require("./lingui"));
-var _minimal = _interopRequireDefault(require("./minimal"));
-var _po = _interopRequireDefault(require("./po"));
-var _poGettext = _interopRequireDefault(require("./po-gettext"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const formats = {
-  lingui: _lingui.default,
-  minimal: _minimal.default,
-  po: _po.default,
-  csv: _csv.default,
-  "po-gettext": _poGettext.default
-};
+var _formatterWrapper = require("./formatterWrapper");
+var _utils = require("../utils");
+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 createDeprecationError(packageName, format, installCode) {
+  const installCmd = (0, _utils.makeInstall)(packageName);
+  return `
+Format \`${format}\` is no longer included in \`@lingui/cli\` by default.
+You need to install it using ${installCmd} command and add to your \`lingui.config.{js,ts}\`:
+        
+import { formatter } from "${packageName}"
 
-/**
- * @internal
- */
+export default {
+  [...]
+  format: ${installCode}
+}
+`.trim();
+}
 
-function getFormat(name) {
-  const format = formats[name];
+// Introduced in v4. Remove this deprecation in v5
+const formats = {
+  lingui: async () => {
+    throw new Error(createDeprecationError("@lingui/format-json", "lingui", 'formatter({style: "lingui"})'));
+  },
+  minimal: async () => {
+    throw new Error(createDeprecationError("@lingui/format-json", "minimal", 'formatter({style: "minimal"})'));
+  },
+  po: async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("@lingui/format-po")))).formatter,
+  csv: async () => {
+    throw new Error(createDeprecationError("@lingui/format-csv", "csv", "formatter()"));
+  },
+  "po-gettext": async () => {
+    throw new Error(createDeprecationError("@lingui/format-po-gettext", "po-gettext", "formatter()"));
+  }
+};
+async function getFormat(_format, options, sourceLocale) {
+  if (typeof _format !== "string") {
+    return new _formatterWrapper.FormatterWrapper(_format, sourceLocale);
+  }
+  const format = formats[_format];
   if (!format) {
-    throw new Error(`Unknown format "${name}". Use one of following: ${Object.keys(formats).join(", ")}`);
+    throw new Error(`Unknown format "${_format}". Use one of following: ${Object.keys(formats).join(", ")}`);
   }
-  return format;
+  return new _formatterWrapper.FormatterWrapper((await format())(options), sourceLocale);
 }

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,26 +70,26 @@ 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() {
   return _fs.default.existsSync(_path.default.resolve("yarn.lock"));
 }
-function makeInstall() {
+function makeInstall(packageName, dev = false) {
   const withYarn = hasYarn();
-  return (packageName, dev = false) => withYarn ? `yarn add ${dev ? "--dev " : ""}${packageName}` : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
+  return withYarn ? `yarn add ${dev ? "--dev " : ""}${packageName}` : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
 }
 
 /**
@@ -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;