@lingui/cli 5.9.2 → 6.0.0-next.0

package/dist/api/ProgramExit.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProgramExit = void 0;
-class ProgramExit extends Error {
+export class ProgramExit extends Error {
     constructor() {
         super();
         this.name = "ProgramExit";
     }
 }
-exports.ProgramExit = ProgramExit;

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

@@ -1,6 +1,6 @@
 import type { ExtractedMessage, LinguiConfigNormalized } from "@lingui/conf";
-import { ExtractedCatalogType } from "../types";
-import { ExtractWorkerPool } from "../extractWorkerPool";
-export declare function extractFromFiles(paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType>;
+import { ExtractedCatalogType } from "../types.js";
+import { ExtractWorkerPool } from "../workerPools.js";
+export declare function extractFromFiles(paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType | undefined>;
 export declare function mergeExtractedMessage(next: ExtractedMessage, messages: ExtractedCatalogType, config: LinguiConfigNormalized): void;
-export declare function extractFromFilesWithWorkerPool(workerPool: ExtractWorkerPool, paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType>;
+export declare function extractFromFilesWithWorkerPool(workerPool: ExtractWorkerPool, paths: string[], config: LinguiConfigNormalized): Promise<ExtractedCatalogType | undefined>;

package/dist/api/catalog/extractFromFiles.js

@@ -1,17 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFromFiles = extractFromFiles;
-exports.mergeExtractedMessage = mergeExtractedMessage;
-exports.extractFromFilesWithWorkerPool = extractFromFilesWithWorkerPool;
-const picocolors_1 = __importDefault(require("picocolors"));
-const path_1 = __importDefault(require("path"));
-const extractors_1 = __importDefault(require("../extractors"));
-const utils_1 = require("../utils");
+import { styleText } from "node:util";
+import path from "path";
+import extract from "../extractors/index.js";
+import { prettyOrigin } from "../utils.js";
+function mergeOrigins(prev, next) {
+    if (!next) {
+        return prev;
+    }
+    return [...prev, next].sort((a, b) => a[0].localeCompare(b[0]));
+}
 function mergePlaceholders(prev, next) {
-    const res = Object.assign({}, prev);
+    const res = { ...prev };
     // Handle case where next is null or undefined
     if (!next)
         return res;
@@ -26,21 +24,20 @@ function mergePlaceholders(prev, next) {
     });
     return res;
 }
-async function extractFromFiles(paths, config) {
+export async function extractFromFiles(paths, config) {
     const messages = {};
     let catalogSuccess = true;
     for (const filename of paths) {
-        const fileSuccess = await (0, extractors_1.default)(filename, (next) => {
+        const fileSuccess = await extract(filename, (next) => {
             mergeExtractedMessage(next, messages, config);
         }, config);
-        catalogSuccess && (catalogSuccess = fileSuccess);
+        catalogSuccess &&= fileSuccess;
     }
     if (!catalogSuccess)
         return undefined;
     return messages;
 }
-function mergeExtractedMessage(next, messages, config) {
-    var _a;
+export function mergeExtractedMessage(next, messages, config) {
     if (!messages[next.id]) {
         messages[next.id] = {
             message: next.message,
@@ -52,27 +49,36 @@ function mergeExtractedMessage(next, messages, config) {
     }
     const prev = messages[next.id];
     // there might be a case when filename was not mapped from sourcemaps
-    const filename = next.origin[0]
-        ? path_1.default.relative(config.rootDir, next.origin[0]).replace(/\\/g, "/")
-        : "";
-    const origin = [filename, next.origin[1]];
+    const nextOrigin = next.origin
+        ? [
+            path.relative(config.rootDir, next.origin[0]).replace(/\\/g, "/"),
+            next.origin[1],
+        ]
+        : undefined;
     if (prev.message && next.message && prev.message !== next.message) {
-        throw new Error(`Encountered different default translations for message ${picocolors_1.default.yellow(next.id)}` +
-            `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)(prev.origin))} ${prev.message}` +
-            `\n${picocolors_1.default.yellow((0, utils_1.prettyOrigin)([origin]))} ${next.message}`);
+        throw new Error(`Encountered different default translations for message ${styleText("yellow", next.id)}` +
+            `\n${styleText("yellow", prettyOrigin(prev.origin))} ${prev.message}` +
+            `\n${styleText("yellow", prettyOrigin([nextOrigin || [""]]))} ${next.message}`);
     }
-    messages[next.id] = Object.assign(Object.assign({}, prev), { message: (_a = prev.message) !== null && _a !== void 0 ? _a : next.message, comments: next.comment
+    messages[next.id] = {
+        ...prev,
+        message: prev.message ?? next.message,
+        comments: next.comment
             ? [...prev.comments, next.comment].sort()
-            : prev.comments, origin: [...prev.origin, [filename, next.origin[1]]].sort((a, b) => a[0].localeCompare(b[0])), placeholders: mergePlaceholders(prev.placeholders, next.placeholders) });
+            : prev.comments,
+        origin: mergeOrigins(prev.origin, nextOrigin),
+        placeholders: mergePlaceholders(prev.placeholders, next.placeholders),
+    };
 }
-async function extractFromFilesWithWorkerPool(workerPool, paths, config) {
+export async function extractFromFilesWithWorkerPool(workerPool, paths, config) {
     const messages = {};
     let catalogSuccess = true;
-    if (!config.resolvedConfigPath) {
+    const resolvedConfigPath = config.resolvedConfigPath;
+    if (!resolvedConfigPath) {
         throw new Error("Multithreading is only supported when lingui config loaded from file system, not passed by API");
     }
-    await Promise.all(paths.map((filename) => workerPool.queue(async (worker) => {
-        const result = await worker(filename, config.resolvedConfigPath);
+    await Promise.all(paths.map(async (filename) => {
+        const result = await workerPool.run(filename, resolvedConfigPath);
         if (!result.success) {
             catalogSuccess = false;
         }
@@ -81,7 +87,7 @@ async function extractFromFilesWithWorkerPool(workerPool, paths, config) {
                 mergeExtractedMessage(message, messages, config);
             });
         }
-    })));
+    }));
     if (!catalogSuccess)
         return undefined;
     return messages;

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

@@ -1,4 +1,4 @@
-import { Catalog } from "../catalog";
+import { Catalog } from "../catalog.js";
 /**
  * Return all files catalog implicitly depends on.
  */

package/dist/api/catalog/getCatalogDependentFiles.js

@@ -1,53 +1,14 @@
-"use strict";
-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]; } };
-    }
-    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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCatalogDependentFiles = getCatalogDependentFiles;
-const getFallbackListForLocale_1 = require("./getFallbackListForLocale");
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const process = __importStar(require("process"));
-const fileExists = async (path) => !!(await promises_1.default.stat(path).catch(() => false));
+import { getFallbackListForLocale } from "./getFallbackListForLocale.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as process from "process";
+const fileExists = async (path) => !!(await fs.stat(path).catch(() => false));
 /**
  * Return all files catalog implicitly depends on.
  */
-async function getCatalogDependentFiles(catalog, locale) {
+export async function getCatalogDependentFiles(catalog, locale) {
     const files = new Set([catalog.templateFile]);
-    (0, getFallbackListForLocale_1.getFallbackListForLocale)(catalog.config.fallbackLocales, locale).forEach((locale) => {
+    getFallbackListForLocale(catalog.config.fallbackLocales, locale).forEach((locale) => {
         files.add(catalog.getFilename(locale));
     });
     if (catalog.config.sourceLocale && locale !== catalog.config.sourceLocale) {
@@ -55,7 +16,7 @@ async function getCatalogDependentFiles(catalog, locale) {
     }
     const out = [];
     for (let file of files) {
-        file = node_path_1.default.isAbsolute(file) ? file : node_path_1.default.join(process.cwd(), file);
+        file = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
         if (await fileExists(file)) {
             out.push(file);
         }

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

@@ -1,5 +1,5 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { Catalog } from "../catalog";
+import { Catalog } from "../catalog.js";
 /**
  * Parse `config.catalogs` and return a list of configured Catalog instances.
  */
@@ -11,4 +11,4 @@ export declare function getMergedCatalogPath(config: LinguiConfigNormalized): Pr
 export declare function getCatalogForFile(file: string, catalogs: Catalog[]): {
     locale: string;
     catalog: Catalog;
-};
+} | null;

package/dist/api/catalog/getCatalogs.js

@@ -1,32 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCatalogs = getCatalogs;
-exports.getMergedCatalogPath = getMergedCatalogPath;
-exports.getCatalogForFile = getCatalogForFile;
-const glob_1 = 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");
+import { globSync } from "node:fs";
+import path from "path";
+import { Catalog } from "../catalog.js";
+import { normalizeRelativePath, PATHSEP, replacePlaceholders, } from "../utils.js";
+import micromatch from "micromatch";
+import { getFormat } from "../formats/index.js";
+import { getExperimentalCatalogs } from "../../extract-experimental/getExperimentalCatalogs.js";
 const NAME_PH = "{name}";
 const LOCALE_PH = "{locale}";
 /**
  * Parse `config.catalogs` and return a list of configured Catalog instances.
  */
-async function getCatalogs(config) {
-    var _a, _b;
+export async function getCatalogs(config) {
     const catalogsConfig = config.catalogs;
     const catalogs = [];
-    const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+    const format = await getFormat(config.format, config.sourceLocale);
     catalogsConfig.forEach((catalog) => {
         validateCatalogPath(catalog.path, format.getCatalogExtension());
-        const include = ensureArray(catalog.include).map(utils_1.normalizeRelativePath);
-        const exclude = ensureArray(catalog.exclude).map(utils_1.normalizeRelativePath);
+        const include = ensureArray(catalog.include).map(normalizeRelativePath);
+        const exclude = ensureArray(catalog.exclude).map(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
@@ -37,33 +28,33 @@ async function getCatalogs(config) {
                     ` Either add {name} pattern to "${catalog.path}" or remove it` +
                     ` from all source directories.`);
             }
-            catalogs.push(new catalog_1.Catalog({
+            catalogs.push(new Catalog({
                 name: getCatalogName(catalog.path),
-                path: (0, utils_1.normalizeRelativePath)(catalog.path),
+                path: normalizeRelativePath(catalog.path),
                 include,
                 exclude,
                 format,
             }, config));
             return;
         }
-        const patterns = include.map((path) => (0, utils_1.replacePlaceholders)(path, { name: "*" }));
-        const candidates = (0, glob_1.globSync)(patterns, {
-            ignore: exclude,
-            mark: true,
+        const patterns = include.map((path) => replacePlaceholders(path, { name: "*" }));
+        const candidates = globSync(patterns, {
+            exclude,
         });
         candidates.forEach((catalogDir) => {
-            const name = path_1.default.basename(catalogDir);
-            catalogs.push(new catalog_1.Catalog({
+            const name = path.basename(catalogDir);
+            catalogs.push(new Catalog({
                 name,
-                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 })),
+                path: normalizeRelativePath(replacePlaceholders(catalog.path, { name })),
+                include: include.map((path) => replacePlaceholders(path, { name })),
+                exclude: exclude.map((path) => replacePlaceholders(path, { name })),
                 format,
             }, 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)));
+    if (config.experimental?.extractor &&
+        config.experimental.extractor.entries.length) {
+        catalogs.push(...(await getExperimentalCatalogs(config, format, config.experimental.extractor)));
     }
     return catalogs;
 }
@@ -78,17 +69,17 @@ const ensureArray = (value) => {
 /**
  * Create catalog for merged messages.
  */
-async function getMergedCatalogPath(config) {
-    const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+export async function getMergedCatalogPath(config) {
+    const format = await getFormat(config.format, config.sourceLocale);
     validateCatalogPath(config.catalogsMergePath, format.getCatalogExtension());
-    return (0, utils_1.normalizeRelativePath)(config.catalogsMergePath);
+    return normalizeRelativePath(config.catalogsMergePath);
 }
-function getCatalogForFile(file, catalogs) {
+export function getCatalogForFile(file, catalogs) {
     for (const catalog of catalogs) {
         const catalogFile = `${catalog.path}${catalog.format.getCatalogExtension()}`;
-        const catalogGlob = (0, utils_1.replacePlaceholders)(catalogFile, { locale: "*" });
-        const matchPattern = (0, utils_1.normalizeRelativePath)(path_1.default.relative(catalog.config.rootDir, catalogGlob)).replace(/(\(|\)|\[|\])/g, "\\$1");
-        const match = micromatch_1.default.capture(matchPattern, (0, utils_1.normalizeRelativePath)(file));
+        const catalogGlob = replacePlaceholders(catalogFile, { locale: "*" });
+        const matchPattern = normalizeRelativePath(path.relative(catalog.config.rootDir, catalogGlob)).replace(/(\(|\)|\[|\])/g, "\\$1");
+        const match = micromatch.capture(matchPattern, normalizeRelativePath(file));
         if (match) {
             return {
                 locale: match[0],
@@ -105,11 +96,11 @@ function validateCatalogPath(path, extension) {
     if (!path.includes(LOCALE_PH)) {
         throw new Error(`Invalid catalog path: ${LOCALE_PH} variable is missing`);
     }
-    if (!path.endsWith(utils_1.PATHSEP)) {
+    if (!path.endsWith(PATHSEP)) {
         return;
     }
     const correctPath = path.slice(0, -1);
-    const examplePath = (0, utils_1.replacePlaceholders)(correctPath, {
+    const examplePath = replacePlaceholders(correctPath, {
         locale: "en",
     }) + extension;
     throw new Error(
@@ -121,6 +112,6 @@ function validateCatalogPath(path, extension) {
 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_1.default.basename((0, utils_1.normalizeRelativePath)(filePath));
-    return _name !== LOCALE_PH ? _name : null;
+    const name = path.basename(normalizeRelativePath(filePath));
+    return name !== LOCALE_PH ? name : undefined;
 }

package/dist/api/catalog/getFallbackListForLocale.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFallbackListForLocale = getFallbackListForLocale;
-function getFallbackListForLocale(fallbackLocales, locale) {
+export function getFallbackListForLocale(fallbackLocales, locale) {
     const fL = [];
-    if (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales[locale]) {
-        const mapping = fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales[locale];
+    if (fallbackLocales?.[locale]) {
+        const mapping = fallbackLocales?.[locale];
         Array.isArray(mapping) ? fL.push(...mapping) : fL.push(mapping);
     }
-    if (typeof (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales.default) === "string" &&
-        locale !== (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales.default)) {
+    if (typeof fallbackLocales?.default === "string" &&
+        locale !== fallbackLocales?.default) {
         fL.push(fallbackLocales.default);
     }
     return fL;

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

@@ -1,4 +1,4 @@
-import { Catalog } from "../catalog";
+import { Catalog } from "../catalog.js";
 import { FallbackLocales } from "@lingui/conf";
 export type TranslationMissingEvent = {
     source: string;

package/dist/api/catalog/getTranslationsForCatalog.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTranslationsForCatalog = getTranslationsForCatalog;
-const getFallbackListForLocale_1 = require("./getFallbackListForLocale");
-async function getTranslationsForCatalog(catalog, locale, options) {
+import { getFallbackListForLocale } from "./getFallbackListForLocale.js";
+export async function getTranslationsForCatalog(catalog, locale, options) {
     const locales = new Set([
         locale,
         options.sourceLocale,
-        ...(0, getFallbackListForLocale_1.getFallbackListForLocale)(options.fallbackLocales, locale),
+        ...getFallbackListForLocale(options.fallbackLocales, locale),
     ]);
     const [catalogs, template] = await Promise.all([
         catalog.readAll(Array.from(locales)),
         catalog.readTemplate(),
     ]);
     const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
-    const input = Object.assign(Object.assign(Object.assign({}, template), sourceLocaleCatalog), catalogs[locale]);
+    const input = { ...template, ...sourceLocaleCatalog, ...catalogs[locale] };
     const missing = [];
     const messages = Object.keys(input).reduce((acc, key) => {
         acc[key] = getTranslation(catalogs, input[key], locale, key, (event) => {
@@ -27,20 +24,19 @@ async function getTranslationsForCatalog(catalog, locale, options) {
     };
 }
 function sourceLocaleFallback(catalog, key) {
-    if (!(catalog === null || catalog === void 0 ? void 0 : catalog[key])) {
-        return null;
+    if (!catalog?.[key]) {
+        return undefined;
     }
     return catalog[key].translation || catalog[key].message;
 }
 function getTranslation(catalogs, msg, locale, key, onMissing, options) {
     const { fallbackLocales, sourceLocale } = options;
     const getTranslation = (_locale) => {
-        var _a;
         const localeCatalog = catalogs[_locale];
-        return (_a = localeCatalog === null || localeCatalog === void 0 ? void 0 : localeCatalog[key]) === null || _a === void 0 ? void 0 : _a.translation;
+        return localeCatalog?.[key]?.translation;
     };
     const getMultipleFallbacks = (_locale) => {
-        const fL = (0, getFallbackListForLocale_1.getFallbackListForLocale)(fallbackLocales, _locale);
+        const fL = getFallbackListForLocale(fallbackLocales, _locale);
         if (!fL.length)
             return null;
         for (const fallbackLocale of fL) {
@@ -66,7 +62,7 @@ function getTranslation(catalogs, msg, locale, key, onMissing, options) {
     if (!translation) {
         onMissing({
             id: key,
-            source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key),
+            source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key) || "",
         });
     }
     return (translation ||

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

@@ -1,3 +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;
+import type { MergeOptions } from "../catalog.js";
+import { CatalogType, ExtractedCatalogType } from "../types.js";
+export declare function mergeCatalog(prevCatalog: CatalogType | undefined, nextCatalog: ExtractedCatalogType, forSourceLocale: boolean, options: MergeOptions): CatalogType;

package/dist/api/catalog/mergeCatalog.js

@@ -1,27 +1,17 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeCatalog = mergeCatalog;
-function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
+export function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
+    prevCatalog = prevCatalog || {};
     const nextKeys = Object.keys(nextCatalog);
-    const prevKeys = Object.keys(prevCatalog || {});
+    const prevKeys = Object.keys(prevCatalog);
     const newKeys = nextKeys.filter((key) => !prevKeys.includes(key));
     const mergeKeys = nextKeys.filter((key) => prevKeys.includes(key));
     const obsoleteKeys = prevKeys.filter((key) => !nextKeys.includes(key));
     // Initialize new catalog with new keys
     const newMessages = Object.fromEntries(newKeys.map((key) => [
         key,
-        Object.assign({ translation: forSourceLocale ? nextCatalog[key].message || key : "" }, nextCatalog[key]),
+        {
+            translation: forSourceLocale ? nextCatalog[key].message || key : "",
+            ...nextCatalog[key],
+        },
     ]));
     // Merge translations from previous catalog
     const mergedMessages = Object.fromEntries(mergeKeys.map((key) => {
@@ -31,15 +21,17 @@ function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
         const translation = updateFromDefaults
             ? nextCatalog[key].message || key
             : prevCatalog[key].translation;
-        const _a = nextCatalog[key], { obsolete } = _a, rest = __rest(_a, ["obsolete"]);
         const { extra } = prevCatalog[key];
-        return [key, Object.assign(Object.assign(Object.assign({}, extra), rest), { translation })];
+        return [key, { ...extra, ...nextCatalog[key], translation }];
     }));
     // Mark all remaining translations as obsolete
     // Only if *options.files* is not provided
     const obsoleteMessages = Object.fromEntries(obsoleteKeys.map((key) => [
         key,
-        Object.assign(Object.assign({}, prevCatalog[key]), (options.files ? {} : { obsolete: true })),
+        {
+            ...prevCatalog[key],
+            ...(options.files ? {} : { obsolete: true }),
+        },
     ]));
-    return Object.assign(Object.assign(Object.assign({}, newMessages), mergedMessages), obsoleteMessages);
+    return { ...newMessages, ...mergedMessages, ...obsoleteMessages };
 }

package/dist/api/catalog.d.ts

@@ -1,20 +1,20 @@
 import { LinguiConfigNormalized, OrderBy, OrderByFn } from "@lingui/conf";
-import { FormatterWrapper } from "./formats";
-import { CompiledCatalogNamespace } from "./compile";
-import { GetTranslationsOptions } from "./catalog/getTranslationsForCatalog";
-import { AllCatalogsType, CatalogType, ExtractedCatalogType } from "./types";
-import { ExtractWorkerPool } from "./extractWorkerPool";
+import { FormatterWrapper } from "./formats/index.js";
+import { CompiledCatalogNamespace } from "./compile.js";
+import { GetTranslationsOptions } from "./catalog/getTranslationsForCatalog.js";
+import { AllCatalogsType, CatalogType, ExtractedCatalogType } from "./types.js";
+import { ExtractWorkerPool } from "./workerPools.js";
 export type MakeOptions = {
     files?: string[];
     clean: boolean;
     overwrite: boolean;
-    locale: string[];
-    orderBy?: OrderBy;
+    locale?: string[];
+    orderBy: OrderBy;
     workerPool?: ExtractWorkerPool;
 };
 export type MakeTemplateOptions = {
     files?: string[];
-    orderBy?: OrderBy;
+    orderBy: OrderBy;
     workerPool?: ExtractWorkerPool;
 };
 export type MergeOptions = {
@@ -36,7 +36,7 @@ export declare class Catalog {
     include: Array<string>;
     exclude: Array<string>;
     format: FormatterWrapper;
-    templateFile?: string;
+    templateFile: string;
     constructor({ name, path, include, templatePath, format, exclude }: CatalogProps, config: LinguiConfigNormalized);
     getFilename(locale: string): string;
     make(options: MakeOptions): Promise<AllCatalogsType | false>;
@@ -52,21 +52,21 @@ export declare class Catalog {
         [k: string]: CatalogType;
     };
     getTranslations(locale: string, options: GetTranslationsOptions): Promise<{
-        missing: import("./catalog/getTranslationsForCatalog").TranslationMissingEvent[];
+        missing: import("./catalog/getTranslationsForCatalog.js").TranslationMissingEvent[];
         messages: {
             [id: string]: string;
         };
     }>;
     write(locale: string, messages: CatalogType): Promise<[created: boolean, filename: string]>;
     writeTemplate(messages: CatalogType): Promise<void>;
-    read(locale: string): Promise<CatalogType>;
+    read(locale: string): Promise<CatalogType | undefined>;
     readAll(locales?: string[]): Promise<AllCatalogsType>;
-    readTemplate(): Promise<CatalogType>;
+    readTemplate(): Promise<CatalogType | undefined>;
     get sourcePaths(): string[];
     get localeDir(): string;
-    get locales(): string[];
+    get locales(): string[] & never[];
 }
-export declare function cleanObsolete<T extends ExtractedCatalogType>(messages: T): T;
-export declare function order<T extends ExtractedCatalogType>(by: OrderBy, catalog: T): T;
+export declare function cleanObsolete<T extends CatalogType>(messages: T): T;
+export declare function order<T extends CatalogType>(by: OrderBy, catalog: T): T;
 export declare function writeCompiled(path: string, locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
 export declare const orderByMessage: OrderByFn;