@lingui/cli 5.7.0 → 5.9.0

package/dist/api/catalog/mergeCatalog.js

@@ -32,7 +32,8 @@ function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
             ? nextCatalog[key].message || key
             : prevCatalog[key].translation;
         const _a = nextCatalog[key], { obsolete } = _a, rest = __rest(_a, ["obsolete"]);
-        return [key, Object.assign(Object.assign({}, rest), { translation })];
+        const { extra } = prevCatalog[key];
+        return [key, Object.assign(Object.assign(Object.assign({}, extra), rest), { translation })];
     }));
     // Mark all remaining translations as obsolete
     // Only if *options.files* is not provided

package/dist/api/catalog.d.ts

@@ -1,4 +1,4 @@
-import { LinguiConfigNormalized, OrderBy } from "@lingui/conf";
+import { LinguiConfigNormalized, OrderBy, OrderByFn } from "@lingui/conf";
 import { FormatterWrapper } from "./formats";
 import { CompiledCatalogNamespace } from "./compile";
 import { GetTranslationsOptions } from "./catalog/getTranslationsForCatalog";
@@ -69,4 +69,4 @@ export declare class Catalog {
 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 writeCompiled(path: string, locale: string, compiledCatalog: string, namespace?: CompiledCatalogNamespace): Promise<string>;
-export declare function orderByMessage<T extends ExtractedCatalogType>(messages: T): T;
+export declare const orderByMessage: OrderByFn;

package/dist/api/catalog.js

@@ -3,11 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Catalog = void 0;
+exports.orderByMessage = exports.Catalog = void 0;
 exports.cleanObsolete = cleanObsolete;
 exports.order = order;
 exports.writeCompiled = writeCompiled;
-exports.orderByMessage = orderByMessage;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const glob_1 = require("glob");
@@ -140,8 +139,7 @@ class Catalog {
         return await this.format.read(filename, undefined);
     }
     get sourcePaths() {
-        const includeGlobs = this.include
-            .map((includePath) => {
+        const includeGlobs = this.include.map((includePath) => {
             const isDir = (0, utils_1.isDirectory)(includePath);
             /**
              * glob library results from absolute patterns such as /foo/* are mounted onto the root setting using path.join.
@@ -150,8 +148,7 @@ class Catalog {
             return isDir
                 ? (0, normalize_path_1.default)(path_1.default.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*"))
                 : includePath;
-        })
-            .map(utils_1.makePathRegexSafe);
+        });
         return (0, glob_1.globSync)(includeGlobs, { ignore: this.exclude, mark: true });
     }
     get localeDir() {
@@ -173,28 +170,33 @@ function cleanObsolete(messages) {
     return Object.fromEntries(Object.entries(messages).filter(([, message]) => !message.obsolete));
 }
 function order(by, catalog) {
-    return {
-        messageId: orderByMessageId,
-        message: orderByMessage,
-        origin: orderByOrigin,
-    }[by](catalog);
-}
-/**
- * Object keys are in the same order as they were created
- * https://stackoverflow.com/a/31102605/1535540
- */
-function orderByMessageId(messages) {
-    return Object.keys(messages)
-        .sort()
+    const orderByFn = typeof by === "function"
+        ? by
+        : {
+            messageId: orderByMessageId,
+            message: exports.orderByMessage,
+            origin: orderByOrigin,
+        }[by];
+    return Object.keys(catalog)
+        .sort((a, b) => {
+        return orderByFn({ messageId: a, entry: catalog[a] }, { messageId: b, entry: catalog[b] });
+    })
         .reduce((acc, key) => {
         ;
-        acc[key] = messages[key];
+        acc[key] = catalog[key];
         return acc;
     }, {});
 }
-function orderByOrigin(messages) {
-    function getFirstOrigin(messageKey) {
-        const sortedOrigins = messages[messageKey].origin.sort((a, b) => {
+/**
+ * Object keys are in the same order as they were created
+ * https://stackoverflow.com/a/31102605/1535540
+ */
+const orderByMessageId = (a, b) => {
+    return a.messageId.localeCompare(b.messageId);
+};
+const orderByOrigin = (a, b) => {
+    function getFirstOrigin(entry) {
+        const sortedOrigins = entry.origin.sort((a, b) => {
             if (a[0] < b[0])
                 return -1;
             if (a[0] > b[0])
@@ -203,26 +205,18 @@ function orderByOrigin(messages) {
         });
         return sortedOrigins[0];
     }
-    return Object.keys(messages)
-        .sort((a, b) => {
-        const [aFile, aLineNumber] = getFirstOrigin(a);
-        const [bFile, bLineNumber] = getFirstOrigin(b);
-        if (aFile < bFile)
-            return -1;
-        if (aFile > bFile)
-            return 1;
-        if (aLineNumber < bLineNumber)
-            return -1;
-        if (aLineNumber > bLineNumber)
-            return 1;
-        return 0;
-    })
-        .reduce((acc, key) => {
-        ;
-        acc[key] = messages[key];
-        return acc;
-    }, {});
-}
+    const [aFile, aLineNumber] = getFirstOrigin(a.entry);
+    const [bFile, bLineNumber] = getFirstOrigin(b.entry);
+    if (aFile < bFile)
+        return -1;
+    if (aFile > bFile)
+        return 1;
+    if (aLineNumber < bLineNumber)
+        return -1;
+    if (aLineNumber > bLineNumber)
+        return 1;
+    return 0;
+};
 async function writeCompiled(path, locale, compiledCatalog, namespace) {
     let ext;
     switch (namespace) {
@@ -240,21 +234,14 @@ async function writeCompiled(path, locale, compiledCatalog, namespace) {
     await (0, utils_1.writeFile)(filename, compiledCatalog);
     return filename;
 }
-function orderByMessage(messages) {
+const orderByMessage = (a, b) => {
     // hardcoded en-US locale to have consistent sorting
     // @see https://github.com/lingui/js-lingui/pull/1808
     const collator = new Intl.Collator("en-US");
-    return Object.keys(messages)
-        .sort((a, b) => {
-        const aMsg = messages[a].message || "";
-        const bMsg = messages[b].message || "";
-        const aCtxt = messages[a].context || "";
-        const bCtxt = messages[b].context || "";
-        return collator.compare(aMsg, bMsg) || collator.compare(aCtxt, bCtxt);
-    })
-        .reduce((acc, key) => {
-        ;
-        acc[key] = messages[key];
-        return acc;
-    }, {});
-}
+    const aMsg = a.entry.message || "";
+    const bMsg = b.entry.message || "";
+    const aCtxt = a.entry.context || "";
+    const bCtxt = b.entry.context || "";
+    return collator.compare(aMsg, bMsg) || collator.compare(aCtxt, bCtxt);
+};
+exports.orderByMessage = orderByMessage;

package/dist/lingui-extract.js

@@ -34,11 +34,13 @@ async function command(config, options) {
         workerPool = (0, extractWorkerPool_1.createExtractWorkerPool)(options.workersOptions);
     }
     spinner.start();
+    let extractionResult;
     try {
-        await Promise.all(catalogs.map(async (catalog) => {
+        extractionResult = await Promise.all(catalogs.map(async (catalog) => {
             const result = await catalog.make(Object.assign(Object.assign({}, options), { orderBy: config.orderBy, workerPool }));
             catalogStats[(0, normalize_path_1.default)(path_1.default.relative(config.rootDir, catalog.path))] = result || {};
             commandSuccess && (commandSuccess = Boolean(result));
+            return { catalog, messagesByLocale: result };
         }));
     }
     finally {
@@ -70,7 +72,7 @@ async function command(config, options) {
         try {
             const module = require(`./services/${moduleName}`);
             await module
-                .default(config, options)
+                .default(config, options, extractionResult)
                 .then(console.log)
                 .catch(console.error);
         }

package/dist/services/translationIO/segment-converters.d.ts

@@ -0,0 +1,4 @@
+import { MessageType } from "@lingui/conf";
+import { TranslationIoSegment } from "./translationio-api";
+export declare function createSegmentFromLinguiItem(key: string, item: MessageType): TranslationIoSegment;
+export declare function createLinguiItemFromSegment(segment: TranslationIoSegment): readonly [string, MessageType];

package/dist/services/translationIO/segment-converters.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSegmentFromLinguiItem = createSegmentFromLinguiItem;
+exports.createLinguiItemFromSegment = createLinguiItemFromSegment;
+const generateMessageId_1 = require("@lingui/message-utils/generateMessageId");
+const EXPLICIT_ID_FLAG = "js-lingui-explicit-id";
+const EXPLICIT_ID_AND_CONTEXT_FLAG = "js-lingui-explicit-id-and-context";
+function isGeneratedId(id, message) {
+    return id === (0, generateMessageId_1.generateMessageId)(message.message, message.context);
+}
+const joinOrigin = (origin) => origin.join(":");
+const splitOrigin = (origin) => {
+    const [file, line] = origin.split(":");
+    return [file, line ? Number(line) : null];
+};
+function createSegmentFromLinguiItem(key, item) {
+    const itemHasExplicitId = !isGeneratedId(key, item);
+    const itemHasContext = !!item.context;
+    const segment = {
+        type: "source", // No way to edit text for source language (inside code), so not using "key" here
+        source: "",
+        context: "",
+        references: [],
+        comment: "",
+    };
+    // For segment.source & segment.context, we must remain compatible with projects created/synced before Lingui V4
+    if (itemHasExplicitId) {
+        segment.source = item.message || item.translation;
+        segment.context = key;
+    }
+    else {
+        segment.source = item.message || item.translation;
+        if (itemHasContext) {
+            segment.context = item.context;
+        }
+    }
+    if (item.origin) {
+        segment.references = item.origin.map(joinOrigin);
+    }
+    // Since Lingui v4, when using explicit IDs, Lingui automatically adds 'js-lingui-explicit-id' to the extractedComments array
+    const comments = [];
+    if (itemHasExplicitId) {
+        if (itemHasContext) {
+            // segment.context is already used for the explicit ID, so we need to pass the context (for translators) in segment.comment
+            comments.push(item.context, EXPLICIT_ID_AND_CONTEXT_FLAG);
+        }
+        else {
+            comments.push(EXPLICIT_ID_FLAG);
+        }
+    }
+    segment.comment = [...comments, ...(item.comments || [])].join(" | ");
+    return segment;
+}
+function createLinguiItemFromSegment(segment) {
+    var _a, _b, _c;
+    const segmentHasExplicitId = (_a = segment.comment) === null || _a === void 0 ? void 0 : _a.includes(EXPLICIT_ID_FLAG);
+    const segmentHasExplicitIdAndContext = (_b = segment.comment) === null || _b === void 0 ? void 0 : _b.includes(EXPLICIT_ID_AND_CONTEXT_FLAG);
+    const item = {
+        translation: segment.target,
+        origin: ((_c = segment.references) === null || _c === void 0 ? void 0 : _c.length)
+            ? segment.references.map(splitOrigin)
+            : [],
+        message: segment.source,
+        comments: [],
+    };
+    let id = null;
+    if (segmentHasExplicitId || segmentHasExplicitIdAndContext) {
+        id = segment.context;
+    }
+    else {
+        id = (0, generateMessageId_1.generateMessageId)(segment.source, segment.context);
+        item.context = segment.context;
+    }
+    if (segment.comment) {
+        item.comments = segment.comment.split(" | ").filter(
+        // drop flags from comments
+        (comment) => comment !== EXPLICIT_ID_AND_CONTEXT_FLAG && comment !== EXPLICIT_ID_FLAG);
+        // We recompose a target PO Item that is consistent with the source PO Item
+        if (segmentHasExplicitIdAndContext) {
+            item.context = item.comments.shift();
+        }
+    }
+    return [id, item];
+}

package/dist/services/translationIO/translationio-api.d.ts

@@ -0,0 +1,48 @@
+export type TranslationIoSyncRequest = {
+    client: "lingui";
+    version: string;
+    source_language: string;
+    target_languages: string[];
+    segments: TranslationIoSegment[];
+    purge?: boolean;
+};
+export type TranslationIoInitRequest = {
+    client: "lingui";
+    version: string;
+    source_language: string;
+    target_languages: string[];
+    segments: {
+        [locale: string]: TranslationIoSegment[];
+    };
+};
+export type TranslationIoSegment = {
+    type: string;
+    source: string;
+    target?: string;
+    context?: string;
+    references?: string[];
+    comment?: string;
+};
+export type TranslationIoProject = {
+    name: string;
+    url: string;
+};
+export type TranslationIoResponse = {
+    errors?: string[];
+    project?: TranslationIoProject;
+    segments?: {
+        [locale: string]: TranslationIoSegment[];
+    };
+};
+export type FetchResult<T> = {
+    data: T;
+    error: undefined;
+} | {
+    error: {
+        response: Response;
+        message: string;
+    };
+    data: undefined;
+};
+export declare function tioSync(request: TranslationIoSyncRequest, apiKey: string): Promise<FetchResult<TranslationIoResponse>>;
+export declare function tioInit(request: TranslationIoInitRequest, apiKey: string): Promise<FetchResult<TranslationIoResponse>>;

package/dist/services/translationIO/translationio-api.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tioSync = tioSync;
+exports.tioInit = tioInit;
+// todo: need to enable strictNullChecks to support this kind of type narrowing
+// export type TranslationIoResponse =
+//   | TranslationIoErrorResponse
+//   | TranslationProjectResponse
+//
+// type TranslationIoErrorResponse = {
+//   errors: string[]
+// }
+// type TranslationProjectResponse = {
+//   errors: null
+//   project: TranslationIoProject
+//   segments: { [locale: string]: TranslationIoSegment[] }
+// }
+async function post(url, request) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok && response.status !== 400) {
+        return {
+            error: {
+                response,
+                message: `Request failed with ${response.status} ${response.statusText} status. Body: ${await response.text()}`,
+            },
+            data: undefined,
+        };
+    }
+    return { data: await response.json(), error: undefined };
+}
+async function tioSync(request, apiKey) {
+    return post(`https://translation.io/api/v1/segments/sync.json?api_key=${apiKey}`, request);
+}
+async function tioInit(request, apiKey) {
+    return post(`https://translation.io/api/v1/segments/init.json?api_key=${apiKey}`, request);
+}

package/dist/services/translationIO.d.ts

@@ -1,3 +1,32 @@
 import { LinguiConfigNormalized } from "@lingui/conf";
 import { CliExtractOptions } from "../lingui-extract";
-export default function syncProcess(config: LinguiConfigNormalized, options: CliExtractOptions): Promise<string>;
+import { TranslationIoProject, TranslationIoSegment } from "./translationIO/translationio-api";
+import { Catalog } from "../api/catalog";
+import { AllCatalogsType } from "../api/types";
+type ExtractionResult = {
+    catalog: Catalog;
+    messagesByLocale: AllCatalogsType;
+}[];
+export default function syncProcess(config: LinguiConfigNormalized, options: CliExtractOptions, extractionResult: ExtractionResult): Promise<string>;
+export declare function init(config: LinguiConfigNormalized, extractionResult: ExtractionResult): Promise<{
+    readonly success: false;
+    readonly errors: string[];
+    readonly project?: undefined;
+} | {
+    readonly success: true;
+    readonly project: TranslationIoProject;
+    readonly errors?: string[];
+}>;
+export declare function sync(config: LinguiConfigNormalized, options: CliExtractOptions, extractionResult: ExtractionResult): Promise<{
+    readonly success: false;
+    readonly errors: string[];
+    readonly project?: undefined;
+} | {
+    readonly success: true;
+    readonly project: TranslationIoProject;
+    readonly errors?: string[];
+}>;
+export declare function writeSegmentsToCatalogs(config: LinguiConfigNormalized, sourceLocale: string, extractionResult: ExtractionResult, segmentsPerLocale: {
+    [locale: string]: TranslationIoSegment[];
+}): Promise<void>;
+export {};

package/dist/services/translationIO.js

@@ -4,130 +4,103 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = syncProcess;
+exports.init = init;
+exports.sync = sync;
+exports.writeSegmentsToCatalogs = writeSegmentsToCatalogs;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = require("path");
-const pofile_1 = __importDefault(require("pofile"));
-const https_1 = __importDefault(require("https"));
-const glob_1 = require("glob");
-const date_fns_1 = require("date-fns");
-const EXPLICIT_ID_FLAG = "js-lingui-explicit-id";
-const EXPLICIT_ID_AND_CONTEXT_FLAG = "js-lingui-explicit-id-and-context";
-const getCreateHeaders = (language) => ({
-    "POT-Creation-Date": (0, date_fns_1.format)(new Date(), "yyyy-MM-dd HH:mmxxxx"),
-    "MIME-Version": "1.0",
-    "Content-Type": "text/plain; charset=utf-8",
-    "Content-Transfer-Encoding": "8bit",
-    "X-Generator": "@lingui/cli",
-    Language: language,
-});
+const translationio_api_1 = require("./translationIO/translationio-api");
+const catalog_1 = require("../api/catalog");
+const segment_converters_1 = require("./translationIO/segment-converters");
 const getTargetLocales = (config) => {
     const sourceLocale = config.sourceLocale || "en";
     const pseudoLocale = config.pseudoLocale || "pseudo";
     return config.locales.filter((value) => value != sourceLocale && value != pseudoLocale);
 };
-const validCatalogFormat = (config) => {
-    if (typeof config.format === "string") {
-        return config.format === "po";
-    }
-    return config.format.catalogExtension === ".po";
-};
 // Main sync method, call "Init" or "Sync" depending on the project context
-async function syncProcess(config, options) {
-    if (!validCatalogFormat(config)) {
-        console.error(`\n----------\nTranslation.io service is only compatible with the "po" format. Please update your Lingui configuration accordingly.\n----------`);
-        process.exit(1);
+async function syncProcess(config, options, extractionResult) {
+    const reportSuccess = (project) => {
+        return `\n----------\nProject successfully synchronized. Please use this URL to translate: ${project.url}\n----------`;
+    };
+    const reportError = (errors) => {
+        throw `\n----------\nSynchronization with Translation.io failed: ${errors.join(", ")}\n----------`;
+    };
+    const { success, project, errors } = await init(config, extractionResult);
+    if (success) {
+        return reportSuccess(project);
     }
-    return await new Promise((resolve, reject) => {
-        const successCallback = (project) => {
-            resolve(`\n----------\nProject successfully synchronized. Please use this URL to translate: ${project.url}\n----------`);
-        };
-        const failCallback = (errors) => {
-            reject(`\n----------\nSynchronization with Translation.io failed: ${errors.join(", ")}\n----------`);
-        };
-        init(config, options, successCallback, (errors) => {
-            if (errors.length &&
-                errors[0] === "This project has already been initialized.") {
-                sync(config, options, successCallback, failCallback);
-            }
-            else {
-                failCallback(errors);
-            }
-        });
-    });
+    if (errors[0] === "This project has already been initialized.") {
+        const { success, project, errors } = await sync(config, options, extractionResult);
+        if (success) {
+            return reportSuccess(project);
+        }
+        return reportError(errors);
+    }
+    return reportError(errors);
 }
 // Initialize project with source and existing translations (only first time!)
 // Cf. https://translation.io/docs/create-library#initialization
-function init(config, options, successCallback, failCallback) {
+async function init(config, extractionResult) {
     const sourceLocale = config.sourceLocale || "en";
     const targetLocales = getTargetLocales(config);
-    const paths = poPathsPerLocale(config);
     const segments = {};
     targetLocales.forEach((targetLocale) => {
         segments[targetLocale] = [];
     });
     // Create segments from source locale PO items
-    paths[sourceLocale].forEach((path) => {
-        const raw = fs_1.default.readFileSync(path).toString();
-        const po = pofile_1.default.parse(raw);
-        po.items
-            .filter((item) => !item["obsolete"])
-            .forEach((item) => {
+    for (const { messagesByLocale } of extractionResult) {
+        const messages = messagesByLocale[sourceLocale];
+        Object.entries(messages).forEach(([key, entry]) => {
+            if (entry.obsolete)
+                return;
             targetLocales.forEach((targetLocale) => {
-                const newSegment = createSegmentFromPoItem(item);
-                segments[targetLocale].push(newSegment);
+                segments[targetLocale].push((0, segment_converters_1.createSegmentFromLinguiItem)(key, entry));
             });
         });
-    });
+    }
     // Add translations to segments from target locale PO items
-    targetLocales.forEach((targetLocale) => {
-        paths[targetLocale].forEach((path) => {
-            const raw = fs_1.default.readFileSync(path).toString();
-            const po = pofile_1.default.parse(raw);
-            po.items
-                .filter((item) => !item["obsolete"])
-                .forEach((item, index) => {
-                segments[targetLocale][index].target = item.msgstr[0];
+    for (const { messagesByLocale } of extractionResult) {
+        for (const targetLocale of targetLocales) {
+            const messages = messagesByLocale[targetLocale];
+            Object.entries(messages)
+                .filter(([, entry]) => !entry.obsolete)
+                .forEach(([, entry], index) => {
+                segments[targetLocale][index].target = entry.translation;
             });
-        });
-    });
-    const request = {
+        }
+    }
+    const { data, error } = await (0, translationio_api_1.tioInit)({
         client: "lingui",
         version: require("@lingui/core/package.json").version,
         source_language: sourceLocale,
         target_languages: targetLocales,
         segments: segments,
-    };
-    postTio("init", request, config.service.apiKey, (response) => {
-        if (response.errors) {
-            failCallback(response.errors);
-        }
-        else {
-            saveSegmentsToTargetPos(config, paths, response.segments);
-            successCallback(response.project);
-        }
-    }, (error) => {
-        console.error(`\n----------\nSynchronization with Translation.io failed: ${error}\n----------`);
-    });
+    }, config.service.apiKey);
+    if (error) {
+        return { success: false, errors: [error.message] };
+    }
+    if (data.errors) {
+        return { success: false, errors: data.errors };
+    }
+    await writeSegmentsToCatalogs(config, sourceLocale, extractionResult, data.segments);
+    return { success: true, project: data.project };
 }
 // Send all source text from PO to Translation.io and create new PO based on received translations
 // Cf. https://translation.io/docs/create-library#synchronization
-function sync(config, options, successCallback, failCallback) {
+async function sync(config, options, extractionResult) {
     const sourceLocale = config.sourceLocale || "en";
     const targetLocales = getTargetLocales(config);
-    const paths = poPathsPerLocale(config);
     const segments = [];
     // Create segments with correct source
-    paths[sourceLocale].forEach((path) => {
-        const raw = fs_1.default.readFileSync(path).toString();
-        const po = pofile_1.default.parse(raw);
-        po.items
-            .filter((item) => !item["obsolete"])
-            .forEach((item) => {
-            const newSegment = createSegmentFromPoItem(item);
-            segments.push(newSegment);
+    for (const { messagesByLocale } of extractionResult) {
+        const messages = messagesByLocale[sourceLocale];
+        Object.entries(messages).forEach(([key, entry]) => {
+            if (entry.obsolete)
+                return;
+            segments.push((0, segment_converters_1.createSegmentFromLinguiItem)(key, entry));
         });
-    });
-    const request = {
+    }
+    const { data, error } = await (0, translationio_api_1.tioSync)({
         client: "lingui",
         version: require("@lingui/core/package.json").version,
         source_language: sourceLocale,
@@ -135,172 +108,47 @@ function sync(config, options, successCallback, failCallback) {
         segments: segments,
         // Sync and then remove unused segments (not present in the local application) from Translation.io
         purge: Boolean(options.clean),
-    };
-    postTio("sync", request, config.service.apiKey, (response) => {
-        if (response.errors) {
-            failCallback(response.errors);
-        }
-        else {
-            saveSegmentsToTargetPos(config, paths, response.segments);
-            successCallback(response.project);
-        }
-    }, (error) => {
-        console.error(`\n----------\nSynchronization with Translation.io failed: ${error}\n----------`);
-    });
-}
-function createSegmentFromPoItem(item) {
-    const itemHasExplicitId = item.extractedComments.includes(EXPLICIT_ID_FLAG);
-    const itemHasContext = item.msgctxt != null;
-    const segment = {
-        type: "source", // No way to edit text for source language (inside code), so not using "key" here
-        source: "",
-        context: "",
-        references: [],
-        comment: "",
-    };
-    // For segment.source & segment.context, we must remain compatible with projects created/synced before Lingui V4
-    if (itemHasExplicitId) {
-        segment.source = item.msgstr[0];
-        segment.context = item.msgid;
-    }
-    else {
-        segment.source = item.msgid;
-        if (itemHasContext) {
-            segment.context = item.msgctxt;
-        }
+    }, config.service.apiKey);
+    if (error) {
+        return { success: false, errors: [error.message] };
     }
-    if (item.references.length) {
-        segment.references = item.references;
+    if (data.errors) {
+        return { success: false, errors: data.errors };
     }
-    // Since Lingui v4, when using explicit IDs, Lingui automatically adds 'js-lingui-explicit-id' to the extractedComments array
-    if (item.extractedComments.length) {
-        segment.comment = item.extractedComments.join(" | ");
-        if (itemHasExplicitId && itemHasContext) {
-            // segment.context is already used for the explicit ID, so we need to pass the context (for translators) in segment.comment
-            segment.comment = `${item.msgctxt} | ${segment.comment}`;
-            // Replace the flag to let us know how to recompose a target PO Item that is consistent with the source PO Item
-            segment.comment = segment.comment.replace(EXPLICIT_ID_FLAG, EXPLICIT_ID_AND_CONTEXT_FLAG);
-        }
-    }
-    return segment;
+    await writeSegmentsToCatalogs(config, sourceLocale, extractionResult, data.segments);
+    return { success: true, project: data.project };
 }
-function createPoItemFromSegment(segment) {
-    var _a, _b;
-    const segmentHasExplicitId = (_a = segment.comment) === null || _a === void 0 ? void 0 : _a.includes(EXPLICIT_ID_FLAG);
-    const segmentHasExplicitIdAndContext = (_b = segment.comment) === null || _b === void 0 ? void 0 : _b.includes(EXPLICIT_ID_AND_CONTEXT_FLAG);
-    const item = new pofile_1.default.Item();
-    if (segmentHasExplicitId || segmentHasExplicitIdAndContext) {
-        item.msgid = segment.context;
-    }
-    else {
-        item.msgid = segment.source;
-        item.msgctxt = segment.context;
-    }
-    item.msgstr = [segment.target];
-    item.references =
-        segment.references && segment.references.length ? segment.references : [];
-    if (segment.comment) {
-        segment.comment = segment.comment.replace(EXPLICIT_ID_AND_CONTEXT_FLAG, EXPLICIT_ID_FLAG);
-        item.extractedComments = segment.comment ? segment.comment.split(" | ") : [];
-        // We recompose a target PO Item that is consistent with the source PO Item
-        if (segmentHasExplicitIdAndContext) {
-            item.msgctxt = item.extractedComments.shift();
-        }
-    }
-    return item;
-}
-function saveSegmentsToTargetPos(config, paths, segmentsPerLocale) {
-    Object.keys(segmentsPerLocale).forEach((targetLocale) => {
-        // Remove existing target POs and JS for this target locale
-        paths[targetLocale].forEach((path) => {
-            const jsPath = path.replace(/\.po?$/, "") + ".js";
-            const dirPath = (0, path_1.dirname)(path);
-            // Remove PO, JS and empty dir
-            if (fs_1.default.existsSync(path)) {
-                fs_1.default.unlinkSync(path);
-            }
-            if (fs_1.default.existsSync(jsPath)) {
-                fs_1.default.unlinkSync(jsPath);
-            }
-            if (fs_1.default.existsSync(dirPath) && fs_1.default.readdirSync(dirPath).length === 0) {
-                fs_1.default.rmdirSync(dirPath);
-            }
-        });
-        // Find target path (ignoring {name})
-        const localePath = "".concat(config.catalogs[0].path
-            .replace(/{locale}/g, targetLocale)
-            .replace(/{name}/g, ""), ".po");
-        const segments = segmentsPerLocale[targetLocale];
-        const po = new pofile_1.default();
-        po.headers = getCreateHeaders(targetLocale);
-        const items = [];
-        segments.forEach((segment) => {
-            const item = createPoItemFromSegment(segment);
-            items.push(item);
-        });
-        // Sort items by messageId
-        po.items = items.sort((a, b) => {
-            if (a.msgid < b.msgid) {
-                return -1;
-            }
-            if (a.msgid > b.msgid) {
-                return 1;
-            }
-            return 0;
-        });
-        // Check that localePath directory exists and save PO file
-        fs_1.default.promises.mkdir((0, path_1.dirname)(localePath), { recursive: true }).then(() => {
-            po.save(localePath, (err) => {
-                if (err) {
-                    console.error("Error while saving target PO files:");
-                    console.error(err);
-                    process.exit(1);
+async function writeSegmentsToCatalogs(config, sourceLocale, extractionResult, segmentsPerLocale) {
+    // Create segments from source locale PO items
+    for (const { catalog, messagesByLocale } of extractionResult) {
+        const sourceMessages = messagesByLocale[sourceLocale];
+        for (const targetLocale of Object.keys(segmentsPerLocale)) {
+            // Remove existing target POs and JS for this target locale
+            {
+                const path = catalog.getFilename(targetLocale);
+                const jsPath = path.replace(new RegExp(`${catalog.format.getCatalogExtension()}$`), "") + ".js";
+                const dirPath = (0, path_1.dirname)(path);
+                // todo: check tests and all these logic, maybe it could be simplified to just drop the folder
+                // Remove PO, JS and empty dir
+                if (fs_1.default.existsSync(path)) {
+                    await fs_1.default.promises.unlink(path);
+                }
+                if (fs_1.default.existsSync(jsPath)) {
+                    await fs_1.default.promises.unlink(jsPath);
+                }
+                if (fs_1.default.existsSync(dirPath) && fs_1.default.readdirSync(dirPath).length === 0) {
+                    await fs_1.default.promises.rmdir(dirPath);
                 }
-            });
-        });
-    });
-}
-function poPathsPerLocale(config) {
-    const paths = {};
-    config.locales.forEach((locale) => {
-        paths[locale] = [];
-        config.catalogs.forEach((catalog) => {
-            const path = "".concat(catalog.path.replace(/{locale}/g, locale).replace(/{name}/g, "*"), ".po");
-            // If {name} is present (replaced by *), list all the existing POs
-            if (path.includes("*")) {
-                paths[locale] = paths[locale].concat((0, glob_1.globSync)(path));
-            }
-            else {
-                paths[locale].push(path);
             }
-        });
-    });
-    return paths;
-}
-function postTio(action, request, apiKey, successCallback, failCallback) {
-    const jsonRequest = JSON.stringify(request);
-    const options = {
-        hostname: "translation.io",
-        path: `/api/v1/segments/${action}.json?api_key=${apiKey}`,
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-    };
-    const req = https_1.default.request(options, (res) => {
-        res.setEncoding("utf8");
-        let body = "";
-        res.on("data", (chunk) => {
-            body = body.concat(chunk);
-        });
-        res.on("end", () => {
-            const response = JSON.parse(body);
-            successCallback(response);
-        });
-    });
-    req.on("error", (e) => {
-        failCallback(e);
-    });
-    req.write(jsonRequest);
-    req.end();
+            const translations = Object.fromEntries(segmentsPerLocale[targetLocale].map((segment) => (0, segment_converters_1.createLinguiItemFromSegment)(segment)));
+            const messages = Object.fromEntries(Object.entries(sourceMessages).map(([key, entry]) => {
+                var _a;
+                return [
+                    key,
+                    Object.assign(Object.assign({}, entry), { translation: (_a = translations[key]) === null || _a === void 0 ? void 0 : _a.translation }),
+                ];
+            }));
+            await catalog.write(targetLocale, (0, catalog_1.order)(config.orderBy, messages));
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingui/cli",
-  "version": "5.7.0",
+  "version": "5.9.0",
   "description": "CLI for working wit message catalogs",
   "keywords": [
     "cli",
@@ -62,12 +62,12 @@
     "@babel/parser": "^7.22.0",
     "@babel/runtime": "^7.21.0",
     "@babel/types": "^7.21.2",
-    "@lingui/babel-plugin-extract-messages": "5.7.0",
-    "@lingui/babel-plugin-lingui-macro": "5.7.0",
-    "@lingui/conf": "5.7.0",
-    "@lingui/core": "5.7.0",
-    "@lingui/format-po": "5.7.0",
-    "@lingui/message-utils": "5.7.0",
+    "@lingui/babel-plugin-extract-messages": "5.9.0",
+    "@lingui/babel-plugin-lingui-macro": "5.9.0",
+    "@lingui/conf": "5.9.0",
+    "@lingui/core": "5.9.0",
+    "@lingui/format-po": "5.9.0",
+    "@lingui/message-utils": "5.9.0",
     "chokidar": "3.5.1",
     "cli-table": "^0.3.11",
     "commander": "^10.0.0",
@@ -93,7 +93,8 @@
     "@types/normalize-path": "^3.0.0",
     "mock-fs": "^5.2.0",
     "mockdate": "^3.0.5",
+    "msw": "^2.12.7",
     "ts-node": "^10.9.2"
   },
-  "gitHead": "e8c42d548af8fae7365094e58249148fa6a6019f"
+  "gitHead": "491d4c17651c3f76116fe7f63f6bb8a554bef8da"
 }