@lingui/cli 4.0.0-next.5 → 4.0.0-next.7

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

@@ -0,0 +1,5 @@
+import type { LinguiConfigNormalized } from "@lingui/conf";
+import { ExtractedCatalogType } from "../types";
+export declare function extractFromFiles(paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType<{
+    [x: string]: unknown;
+}>>;

package/dist/api/catalog/extractFromFiles.js

@@ -1,64 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "extractFromFiles", {
-    enumerable: true,
-    get: ()=>extractFromFiles
-});
-const _extractors = /*#__PURE__*/ _interopRequireDefault(require("../extractors"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _chalk = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
-const _utils = require("../utils");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFromFiles = void 0;
+const extractors_1 = __importDefault(require("../extractors"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("../utils");
 async function extractFromFiles(paths, config) {
     const messages = {};
     let catalogSuccess = true;
-    for (let filename of paths){
-        const fileSuccess = await (0, _extractors.default)(filename, (next)=>{
+    for (let filename of paths) {
+        const fileSuccess = await (0, extractors_1.default)(filename, (next) => {
             if (!messages[next.id]) {
                 messages[next.id] = {
                     message: next.message,
                     context: next.context,
                     comments: [],
-                    origin: []
+                    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]
-            ];
+            const filename = next.origin[0]
+                ? path_1.default.relative(config.rootDir, next.origin[0]).replace(/\\/g, "/")
+                : "";
+            const origin = [filename, next.origin[1]];
             if (prev.message && next.message && prev.message !== next.message) {
-                throw new Error(`Encountered different default translations for message ${_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}`);
+                throw new Error(`Encountered different default translations for message ${chalk_1.default.yellow(next.id)}` +
+                    `\n${chalk_1.default.yellow((0, utils_1.prettyOrigin)(prev.origin))} ${prev.message}` +
+                    `\n${chalk_1.default.yellow((0, utils_1.prettyOrigin)([origin]))} ${next.message}`);
             }
-            messages[next.id] = {
-                ...prev,
-                comments: next.comment ? [
-                    ...prev.comments,
-                    next.comment
-                ] : prev.comments,
-                origin: [
-                    ...prev.origin,
-                    [
-                        filename,
-                        next.origin[1]
-                    ]
-                ]
-            };
+            messages[next.id] = Object.assign(Object.assign({}, prev), { comments: next.comment
+                    ? [...prev.comments, next.comment]
+                    : prev.comments, origin: [...prev.origin, [filename, next.origin[1]]] });
         }, config, {
-            extractors: config.extractors
+            extractors: config.extractors,
         });
-        catalogSuccess &&= fileSuccess;
+        catalogSuccess && (catalogSuccess = fileSuccess);
     }
-    if (!catalogSuccess) return undefined;
+    if (!catalogSuccess)
+        return undefined;
     return messages;
 }
+exports.extractFromFiles = extractFromFiles;

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

@@ -0,0 +1,14 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { Catalog } from "../catalog";
+/**
+ * Parse `config.catalogs` and return a list of configured Catalog instances.
+ */
+export declare function getCatalogs(config: LinguiConfigNormalized): Promise<Catalog[]>;
+/**
+ * Create catalog for merged messages.
+ */
+export declare function getCatalogForMerge(config: LinguiConfigNormalized): Promise<Catalog>;
+export declare function getCatalogForFile(file: string, catalogs: Catalog[]): {
+    locale: string;
+    catalog: Catalog;
+};

package/dist/api/catalog/getCatalogs.js

@@ -1,137 +1,129 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getCatalogs: ()=>getCatalogs,
-    getCatalogForMerge: ()=>getCatalogForMerge,
-    getCatalogForFile: ()=>getCatalogForFile
-});
-const _glob = /*#__PURE__*/ _interopRequireDefault(require("glob"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _catalog = require("../catalog");
-const _utils = require("../utils");
-const _micromatch = /*#__PURE__*/ _interopRequireDefault(require("micromatch"));
-const _formats = require("../formats");
-const _getExperimentalCatalogs = require("../../extract-experimental/getExperimentalCatalogs");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogForFile = exports.getCatalogForMerge = exports.getCatalogs = void 0;
+const glob_1 = __importDefault(require("glob"));
+const path_1 = __importDefault(require("path"));
+const catalog_1 = require("../catalog");
+const utils_1 = require("../utils");
+const micromatch_1 = __importDefault(require("micromatch"));
+const formats_1 = require("../formats");
+const getExperimentalCatalogs_1 = require("../../extract-experimental/getExperimentalCatalogs");
 const NAME_PH = "{name}";
 const LOCALE_PH = "{locale}";
+/**
+ * Parse `config.catalogs` and return a list of configured Catalog instances.
+ */
 async function getCatalogs(config) {
-    var _config_experimental, _config_experimental_extractor;
+    var _a, _b;
     const catalogsConfig = config.catalogs;
     const catalogs = [];
-    const format = await (0, _formats.getFormat)(config.format, config.formatOptions, config.sourceLocale);
-    catalogsConfig.forEach((catalog)=>{
+    const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+    catalogsConfig.forEach((catalog) => {
         validateCatalogPath(catalog.path, format.getCatalogExtension());
-        const include = ensureArray(catalog.include).map(_utils.normalizeRelativePath);
-        const exclude = ensureArray(catalog.exclude).map(_utils.normalizeRelativePath);
+        const include = ensureArray(catalog.include).map(utils_1.normalizeRelativePath);
+        const exclude = ensureArray(catalog.exclude).map(utils_1.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));
+            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.`);
+                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({
+            catalogs.push(new catalog_1.Catalog({
                 name: getCatalogName(catalog.path),
-                path: (0, _utils.normalizeRelativePath)(catalog.path),
+                path: (0, utils_1.normalizeRelativePath)(catalog.path),
                 include,
                 exclude,
-                format
+                format,
             }, config));
             return;
         }
-        const patterns = include.map((path)=>(0, _utils.replacePlaceholders)(path, {
-                name: "*"
-            }));
-        const candidates = _glob.default.sync(patterns.length > 1 ? `{${patterns.join(",")}}` : patterns[0], {
+        const patterns = include.map((path) => (0, utils_1.replacePlaceholders)(path, { name: "*" }));
+        const candidates = glob_1.default.sync(patterns.length > 1 ? `{${patterns.join(",")}}` : patterns[0], {
             ignore: exclude,
-            mark: true
+            mark: true,
         });
-        candidates.forEach((catalogDir)=>{
-            const name = _path.default.basename(catalogDir);
-            catalogs.push(new _catalog.Catalog({
+        candidates.forEach((catalogDir) => {
+            const name = path_1.default.basename(catalogDir);
+            catalogs.push(new catalog_1.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
-                    })),
-                format
+                path: (0, utils_1.normalizeRelativePath)((0, utils_1.replacePlaceholders)(catalog.path, { name })),
+                include: include.map((path) => (0, utils_1.replacePlaceholders)(path, { name })),
+                exclude: exclude.map((path) => (0, utils_1.replacePlaceholders)(path, { name })),
+                format,
             }, config));
         });
     });
-    if ((_config_experimental = config.experimental) === null || _config_experimental === void 0 ? void 0 : (_config_experimental_extractor = _config_experimental.extractor) === null || _config_experimental_extractor === void 0 ? void 0 : _config_experimental_extractor.entries.length) {
-        catalogs.push(...await (0, _getExperimentalCatalogs.getExperimentalCatalogs)(config));
+    if ((_b = (_a = config.experimental) === null || _a === void 0 ? void 0 : _a.extractor) === null || _b === void 0 ? void 0 : _b.entries.length) {
+        catalogs.push(...(await (0, getExperimentalCatalogs_1.getExperimentalCatalogs)(config)));
     }
     return catalogs;
 }
+exports.getCatalogs = getCatalogs;
 /**
  * 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
-    ];
+ */
+const ensureArray = (value) => {
+    if (value == null)
+        return [];
+    return Array.isArray(value) ? value : [value];
 };
+/**
+ * Create catalog for merged messages.
+ */
 async function getCatalogForMerge(config) {
-    const format = await (0, _formats.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+    const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
     validateCatalogPath(config.catalogsMergePath, format.getCatalogExtension());
-    return new _catalog.Catalog({
+    return new catalog_1.Catalog({
         name: getCatalogName(config.catalogsMergePath),
-        path: (0, _utils.normalizeRelativePath)(config.catalogsMergePath),
+        path: (0, utils_1.normalizeRelativePath)(config.catalogsMergePath),
         include: [],
         exclude: [],
-        format
+        format,
     }, config);
 }
+exports.getCatalogForMerge = getCatalogForMerge;
 function getCatalogForFile(file, catalogs) {
-    for (const catalog of catalogs){
+    for (const catalog of catalogs) {
         const catalogFile = `${catalog.path}${catalog.format.getCatalogExtension()}`;
-        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));
+        const catalogGlob = (0, utils_1.replacePlaceholders)(catalogFile, { locale: "*" });
+        const match = micromatch_1.default.capture((0, utils_1.normalizeRelativePath)(path_1.default.relative(catalog.config.rootDir, catalogGlob)), (0, utils_1.normalizeRelativePath)(file));
         if (match) {
             return {
                 locale: match[0],
-                catalog
+                catalog,
             };
         }
     }
     return null;
 }
+exports.getCatalogForFile = getCatalogForFile;
 /**
  *  Validate that `catalogPath` doesn't end with trailing slash
- */ function validateCatalogPath(path, extension) {
-    if (!path.endsWith(_utils.PATHSEP)) {
+ */
+function validateCatalogPath(path, extension) {
+    if (!path.endsWith(utils_1.PATHSEP)) {
         return;
     }
     const correctPath = path.slice(0, -1);
-    const examplePath = (0, _utils.replacePlaceholders)(correctPath, {
-        locale: "en"
+    const examplePath = (0, utils_1.replacePlaceholders)(correctPath, {
+        locale: "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}".`);
+    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));
+    const _name = path_1.default.basename((0, utils_1.normalizeRelativePath)(filePath));
     return _name !== LOCALE_PH ? _name : null;
 }

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

@@ -0,0 +1,14 @@
+import { Catalog } from "../catalog";
+import { FallbackLocales } from "@lingui/conf";
+export type TranslationMissingEvent = {
+    source: string;
+    id: string;
+};
+export type GetTranslationsOptions = {
+    sourceLocale: string;
+    fallbackLocales: FallbackLocales;
+    onMissing?: (message: TranslationMissingEvent) => void;
+};
+export declare function getTranslationsForCatalog(catalog: Catalog, locale: string, options: GetTranslationsOptions): Promise<{
+    [id: string]: string;
+}>;

package/dist/api/catalog/getTranslationsForCatalog.js

@@ -1,25 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getTranslationsForCatalog", {
-    enumerable: true,
-    get: ()=>getTranslationsForCatalog
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTranslationsForCatalog = void 0;
 async function getTranslationsForCatalog(catalog, locale, options) {
     const catalogs = await catalog.readAll();
-    const template = await catalog.readTemplate() || {};
+    const template = (await catalog.readTemplate()) || {};
     const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
-    const input = {
-        ...template,
-        ...sourceLocaleCatalog,
-        ...catalogs[locale]
-    };
-    return Object.keys(input).reduce((acc, key)=>{
+    const input = Object.assign(Object.assign(Object.assign({}, template), sourceLocaleCatalog), catalogs[locale]);
+    return Object.keys(input).reduce((acc, key) => {
         acc[key] = getTranslation(catalogs, input[key], locale, key, options);
         return acc;
     }, {});
 }
+exports.getTranslationsForCatalog = getTranslationsForCatalog;
 function sourceLocaleFallback(catalog, key) {
     if (!(catalog === null || catalog === void 0 ? void 0 : catalog[key])) {
         return null;
@@ -27,23 +19,25 @@ function sourceLocaleFallback(catalog, key) {
     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 { fallbackLocales, sourceLocale, onMissing } = options;
+    const getTranslation = (_locale) => {
+        var _a;
         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;
+        return (_a = localeCatalog === null || localeCatalog === void 0 ? void 0 : localeCatalog[key]) === null || _a === void 0 ? void 0 : _a.translation;
     };
-    const getMultipleFallbacks = (_locale)=>{
+    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 (!fL)
+            return null;
         if (Array.isArray(fL)) {
-            for (const fallbackLocale of fL){
+            for (const fallbackLocale of fL) {
                 if (catalogs[fallbackLocale] && getTranslation(fallbackLocale)) {
                     return getTranslation(fallbackLocale);
                 }
             }
-        } else {
+        }
+        else {
             return getTranslation(fL);
         }
     };
@@ -53,16 +47,26 @@ function getTranslation(catalogs, msg, locale, key, options) {
     // -> 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);
+    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)
-        });
+        onMissing &&
+            onMissing({
+                id: key,
+                source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key),
+            });
     }
-    return translation || sourceLocale && sourceLocaleFallback(catalogs[sourceLocale], key) || // take from template
-    msg.message || key;
+    return (translation ||
+        (sourceLocale && sourceLocaleFallback(catalogs[sourceLocale], key)) ||
+        // take from template
+        msg.message ||
+        key);
 }

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

@@ -0,0 +1,3 @@
+import type { MergeOptions } from "../catalog";
+import { CatalogType, ExtractedCatalogType } from "../types";
+export declare function mergeCatalog(prevCatalog: CatalogType, nextCatalog: ExtractedCatalogType, forSourceLocale: boolean, options: MergeOptions): CatalogType;

package/dist/api/catalog/mergeCatalog.js

@@ -1,86 +1,55 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "mergeCatalog", {
-    enumerable: true,
-    get: ()=>mergeCatalog
-});
-const _ramda = /*#__PURE__*/ _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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    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;
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCatalog = void 0;
+const R = __importStar(require("ramda"));
 function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
     const nextKeys = Object.keys(nextCatalog);
-    const prevKeys = _ramda.keys(prevCatalog).map(String);
-    const newKeys = _ramda.difference(nextKeys, prevKeys);
-    const mergeKeys = _ramda.intersection(nextKeys, prevKeys);
-    const obsoleteKeys = _ramda.difference(prevKeys, nextKeys);
+    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 = _ramda.mapObjIndexed((message, key)=>({
-            translation: forSourceLocale ? message.message || key : "",
-            ...message
-        }), _ramda.pick(newKeys, nextCatalog));
+    const newMessages = R.mapObjIndexed((message, key) => (Object.assign({ 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;
+    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,
-                ..._ramda.omit([
-                    "obsolete, translation"
-                ], nextCatalog[key])
-            }
+            [key]: Object.assign({ 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 _ramda.mergeAll([
-        newMessages,
-        ...mergedMessages,
-        ...obsoleteMessages
-    ]);
+    const obsoleteMessages = obsoleteKeys.map((key) => ({
+        [key]: Object.assign(Object.assign({}, prevCatalog[key]), { obsolete: !options.files }),
+    }));
+    return R.mergeAll([newMessages, ...mergedMessages, ...obsoleteMessages]);
 }
+exports.mergeCatalog = mergeCatalog;

package/dist/api/catalog.d.ts

@@ -0,0 +1,66 @@
+import * as R from "ramda";
+import { LinguiConfigNormalized, OrderBy } from "@lingui/conf";
+import { FormatterWrapper } from "./formats";
+import { CliExtractOptions } from "../lingui-extract";
+import { CliExtractTemplateOptions } from "../lingui-extract-template";
+import { CompiledCatalogNamespace } from "./compile";
+import { GetTranslationsOptions } from "./catalog/getTranslationsForCatalog";
+import { AllCatalogsType, CatalogType, ExtractedCatalogType, ExtractedMessageType } from "./types";
+export type MakeOptions = CliExtractOptions & {
+    orderBy?: OrderBy;
+};
+export type MakeTemplateOptions = CliExtractTemplateOptions & {
+    orderBy?: OrderBy;
+};
+export type MergeOptions = {
+    overwrite?: boolean;
+    files?: string[];
+};
+export type CatalogProps = {
+    name?: string;
+    path: string;
+    include: Array<string>;
+    exclude?: Array<string>;
+    templatePath?: string;
+    format: FormatterWrapper;
+};
+export declare class Catalog {
+    config: LinguiConfigNormalized;
+    name?: string;
+    path: string;
+    include: Array<string>;
+    exclude: Array<string>;
+    format: FormatterWrapper;
+    templateFile?: string;
+    constructor({ name, path, include, templatePath, format, exclude }: CatalogProps, config: LinguiConfigNormalized);
+    make(options: MakeOptions): Promise<AllCatalogsType | false>;
+    makeTemplate(options: MakeTemplateOptions): Promise<CatalogType | false>;
+    /**
+     * Collect messages from source paths. Return a raw message catalog as JSON.
+     */
+    collect(options?: {
+        files?: string[];
+    }): Promise<ExtractedCatalogType | undefined>;
+    merge(prevCatalogs: AllCatalogsType, nextCatalog: ExtractedCatalogType, options: MergeOptions): Record<string, CatalogType<{
+        [x: string]: unknown;
+    }>>;
+    getTranslations(locale: string, options: GetTranslationsOptions): Promise<{
+        [id: string]: string;
+    }>;
+    write(locale: string, messages: CatalogType): Promise<[created: boolean, filename: string]>;
+    writeTemplate(messages: CatalogType): Promise<void>;
+    writeCompiled(locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
+    read(locale: string): Promise<CatalogType>;
+    readAll(): Promise<AllCatalogsType>;
+    readTemplate(): Promise<CatalogType>;
+    get sourcePaths(): string[];
+    get localeDir(): string;
+    get locales(): string[];
+}
+export declare const cleanObsolete: <K extends ExtractedMessageType<{
+    [x: string]: unknown;
+}>[] | R.Dictionary<ExtractedMessageType<{
+    [x: string]: unknown;
+}>>>(source: K) => K extends (infer U)[] ? U[] : K extends R.Dictionary<infer U_1> ? R.Dictionary<U_1> : never;
+export declare function order<T extends ExtractedCatalogType>(by: OrderBy): (catalog: T) => T;
+export declare function orderByMessage<T extends ExtractedCatalogType>(messages: T): T;