@lingui/cli 3.17.1 → 4.0.0-next.0

package/build/api/catalog/extractFromFiles.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractFromFiles = extractFromFiles;
+var _extractors = _interopRequireDefault(require("../extractors"));
+var _path = _interopRequireDefault(require("path"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function extractFromFiles(paths, config) {
+  const messages = {};
+  let catalogSuccess = true;
+  for (let filename of paths) {
+    const fileSuccess = await (0, _extractors.default)(filename, next => {
+      if (!messages[next.id]) {
+        messages[next.id] = {
+          message: next.message,
+          context: next.context,
+          extractedComments: [],
+          origin: []
+        };
+      }
+      const prev = messages[next.id];
+
+      // there might be a case when filename was not mapped from sourcemaps
+      const filename = next.origin[0] ? _path.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 ${_chalk.default.yellow(next.id)}` + `\n${_chalk.default.yellow((0, _utils.prettyOrigin)(prev.origin))} ${prev.message}` + `\n${_chalk.default.yellow((0, _utils.prettyOrigin)([origin]))} ${next.message}`);
+      }
+      messages[next.id] = {
+        ...prev,
+        extractedComments: next.comment ? [...prev.extractedComments, next.comment] : prev.extractedComments,
+        origin: [...prev.origin, [filename, next.origin[1]]]
+      };
+    }, config, {
+      extractors: config.extractors
+    });
+    catalogSuccess && (catalogSuccess = fileSuccess);
+  }
+  if (!catalogSuccess) return undefined;
+  return messages;
+}

package/build/api/catalog/getCatalogs.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCatalogForFile = getCatalogForFile;
+exports.getCatalogForMerge = getCatalogForMerge;
+exports.getCatalogs = getCatalogs;
+var _glob = _interopRequireDefault(require("glob"));
+var _path = _interopRequireDefault(require("path"));
+var _catalog = require("../catalog");
+var _utils = require("../utils");
+var _micromatch = _interopRequireDefault(require("micromatch"));
+var _formats = require("../formats");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const NAME_PH = "{name}";
+const LOCALE_PH = "{locale}";
+
+/**
+ * Parse `config.catalogs` and return a list of configured Catalog instances.
+ */
+function getCatalogs(config) {
+  const catalogsConfig = config.catalogs;
+  const catalogs = [];
+  catalogsConfig.forEach(catalog => {
+    validateCatalogPath(catalog.path, config);
+    const include = ensureArray(catalog.include).map(_utils.normalizeRelativePath);
+    const exclude = ensureArray(catalog.exclude).map(_utils.normalizeRelativePath);
+
+    // catalog.path without {name} pattern -> always refers to a single catalog
+    if (!catalog.path.includes(NAME_PH)) {
+      // Validate that sourcePaths doesn't use {name} pattern either
+      const invalidSource = include.find(path => path.includes(NAME_PH));
+      if (invalidSource !== undefined) {
+        throw new Error(`Catalog with path "${catalog.path}" doesn't have a {name} pattern` + ` in it, but one of source directories uses it: "${invalidSource}".` + ` Either add {name} pattern to "${catalog.path}" or remove it` + ` from all source directories.`);
+      }
+      catalogs.push(new _catalog.Catalog({
+        name: getCatalogName(catalog.path),
+        path: (0, _utils.normalizeRelativePath)(catalog.path),
+        include,
+        exclude
+      }, config));
+      return;
+    }
+    const patterns = include.map(path => (0, _utils.replacePlaceholders)(path, {
+      name: "*"
+    }));
+    const candidates = _glob.default.sync(patterns.length > 1 ? `{${patterns.join(",")}}` : patterns[0], {
+      ignore: exclude,
+      mark: true
+    });
+    candidates.forEach(catalogDir => {
+      const name = _path.default.basename(catalogDir);
+      catalogs.push(new _catalog.Catalog({
+        name,
+        path: (0, _utils.normalizeRelativePath)((0, _utils.replacePlaceholders)(catalog.path, {
+          name
+        })),
+        include: include.map(path => (0, _utils.replacePlaceholders)(path, {
+          name
+        })),
+        exclude: exclude.map(path => (0, _utils.replacePlaceholders)(path, {
+          name
+        }))
+      }, config));
+    });
+  });
+  return catalogs;
+}
+
+/**
+ * Ensure that value is always array. If not, turn it into an array of one element.
+ */
+const ensureArray = value => {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+};
+
+/**
+ * Create catalog for merged messages.
+ */
+function getCatalogForMerge(config) {
+  validateCatalogPath(config.catalogsMergePath, config);
+  return new _catalog.Catalog({
+    name: getCatalogName(config.catalogsMergePath),
+    path: (0, _utils.normalizeRelativePath)(config.catalogsMergePath),
+    include: [],
+    exclude: []
+  }, config);
+}
+function getCatalogForFile(file, catalogs) {
+  for (const catalog of catalogs) {
+    const catalogFile = `${catalog.path}${catalog.format.catalogExtension}`;
+    const catalogGlob = (0, _utils.replacePlaceholders)(catalogFile, {
+      locale: "*"
+    });
+    const match = _micromatch.default.capture((0, _utils.normalizeRelativePath)(_path.default.relative(catalog.config.rootDir, catalogGlob)), (0, _utils.normalizeRelativePath)(file));
+    if (match) {
+      return {
+        locale: match[0],
+        catalog
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ *  Validate that `catalogPath` doesn't end with trailing slash
+ */
+function validateCatalogPath(path, config) {
+  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"
+  }) + extension;
+  throw new Error(
+  // prettier-ignore
+  `Remove trailing slash from "${path}". Catalog path isn't a directory,` + ` but translation file without extension. For example, catalog path "${correctPath}"` + ` results in translation file "${examplePath}".`);
+}
+function getCatalogName(filePath) {
+  // catalog name is the last directory of catalogPath.
+  // If the last part is {locale}, then catalog doesn't have an explicit name
+  const _name = _path.default.basename((0, _utils.normalizeRelativePath)(filePath));
+  return _name !== LOCALE_PH ? _name : null;
+}

package/build/api/catalog/getTranslationsForCatalog.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTranslationsForCatalog = getTranslationsForCatalog;
+function getTranslationsForCatalog(catalog, locale, options) {
+  const catalogs = catalog.readAll();
+  const template = catalog.readTemplate() || {};
+  const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
+  const input = {
+    ...template,
+    ...sourceLocaleCatalog,
+    ...catalogs[locale]
+  };
+  return Object.keys(input).reduce((acc, key) => {
+    acc[key] = getTranslation(catalogs, input[key], locale, key, options);
+    return acc;
+  }, {});
+}
+function sourceLocaleFallback(catalog, key) {
+  if (!(catalog !== null && catalog !== void 0 && catalog[key])) {
+    return null;
+  }
+  return catalog[key].translation || catalog[key].message;
+}
+function getTranslation(catalogs, msg, locale, key, options) {
+  const {
+    fallbackLocales,
+    sourceLocale,
+    onMissing
+  } = options;
+  const getTranslation = _locale => {
+    var _localeCatalog$key;
+    const localeCatalog = catalogs[_locale];
+    return localeCatalog === null || localeCatalog === void 0 ? void 0 : (_localeCatalog$key = localeCatalog[key]) === null || _localeCatalog$key === void 0 ? void 0 : _localeCatalog$key.translation;
+  };
+  const getMultipleFallbacks = _locale => {
+    const fL = fallbackLocales && (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales[_locale]);
+
+    // some probably the fallback will be undefined, so just search by locale
+    if (!fL) return null;
+    if (Array.isArray(fL)) {
+      for (const fallbackLocale of fL) {
+        if (catalogs[fallbackLocale] && getTranslation(fallbackLocale)) {
+          return getTranslation(fallbackLocale);
+        }
+      }
+    } else {
+      return getTranslation(fL);
+    }
+  };
+
+  // target locale -> fallback locales -> fallback locales default ->
+  // ** (following fallbacks would emit `missing` warning) **
+  // -> source locale translation -> source locale message
+  // -> template message
+  // ** last resort **
+  // -> id
+
+  let translation =
+  // Get translation in target locale
+  getTranslation(locale) ||
+  // We search in fallbackLocales as dependent of each locale
+  getMultipleFallbacks(locale) ||
+  // Get translation in fallbackLocales.default (if any)
+  (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales.default) && getTranslation(fallbackLocales.default) || sourceLocale && sourceLocale === locale && sourceLocaleFallback(catalogs[sourceLocale], key);
+  if (!translation) {
+    onMissing && onMissing({
+      id: key,
+      source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key)
+    });
+  }
+  return translation || sourceLocale && sourceLocaleFallback(catalogs[sourceLocale], key) ||
+  // take from template
+  msg.message || key;
+}

package/build/api/catalog/mergeCatalog.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeCatalog = mergeCatalog;
+var R = _interopRequireWildcard(require("ramda"));
+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 mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
+  const nextKeys = Object.keys(nextCatalog);
+  const prevKeys = R.keys(prevCatalog).map(String);
+  const newKeys = R.difference(nextKeys, prevKeys);
+  const mergeKeys = R.intersection(nextKeys, prevKeys);
+  const obsoleteKeys = R.difference(prevKeys, nextKeys);
+
+  // Initialize new catalog with new keys
+  const newMessages = R.mapObjIndexed((message, key) => ({
+    translation: forSourceLocale ? message.message || key : "",
+    ...message
+  }), R.pick(newKeys, nextCatalog));
+
+  // Merge translations from previous catalog
+  const mergedMessages = mergeKeys.map(key => {
+    const updateFromDefaults = forSourceLocale && (prevCatalog[key].translation === prevCatalog[key].message || options.overwrite);
+    const translation = updateFromDefaults ? nextCatalog[key].message || key : prevCatalog[key].translation;
+    return {
+      [key]: {
+        translation,
+        ...R.omit(["obsolete, translation"], nextCatalog[key])
+      }
+    };
+  });
+
+  // Mark all remaining translations as obsolete
+  // Only if *options.files* is not provided
+  const obsoleteMessages = obsoleteKeys.map(key => ({
+    [key]: {
+      ...prevCatalog[key],
+      obsolete: !options.files
+    }
+  }));
+  return R.mergeAll([newMessages, ...mergedMessages, ...obsoleteMessages]);
+}