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

package/dist/services/translationIO.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // Main sync method, call "Init" or "Sync" depending on the project context
+"default", {
+    enumerable: true,
+    get: ()=>syncProcess
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = require("path");
+const _pofile = /*#__PURE__*/ _interopRequireDefault(require("pofile"));
+const _https = /*#__PURE__*/ _interopRequireDefault(require("https"));
+const _glob = /*#__PURE__*/ _interopRequireDefault(require("glob"));
+const _dateFns = require("date-fns");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const getCreateHeaders = (language)=>({
+        "POT-Creation-Date": (0, _dateFns.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 getTargetLocales = (config)=>{
+    const sourceLocale = config.sourceLocale || "en";
+    const pseudoLocale = config.pseudoLocale || "pseudo";
+    return config.locales.filter((value)=>value != sourceLocale && value != pseudoLocale);
+};
+function syncProcess(config, options) {
+    if (config.format != "po") {
+        console.error(`\n----------\nTranslation.io service is only compatible with the "po" format. Please update your Lingui configuration accordingly.\n----------`);
+        process.exit(1);
+    }
+    const successCallback = (project)=>{
+        console.log(`\n----------\nProject successfully synchronized. Please use this URL to translate: ${project.url}\n----------`);
+    };
+    const failCallback = (errors)=>{
+        console.error(`\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);
+        }
+    });
+}
+// Initialize project with source and existing translations (only first time!)
+// Cf. https://translation.io/docs/create-library#initialization
+function init(config, options, successCallback, failCallback) {
+    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.default.readFileSync(path).toString();
+        const po = _pofile.default.parse(raw);
+        po.items.filter((item)=>!item["obsolete"]).forEach((item)=>{
+            targetLocales.forEach((targetLocale)=>{
+                const newSegment = createSegmentFromPoItem(item);
+                segments[targetLocale].push(newSegment);
+            });
+        });
+    });
+    // Add translations to segments from target locale PO items
+    targetLocales.forEach((targetLocale)=>{
+        paths[targetLocale].forEach((path)=>{
+            const raw = _fs.default.readFileSync(path).toString();
+            const po = _pofile.default.parse(raw);
+            po.items.filter((item)=>!item["obsolete"]).forEach((item, index)=>{
+                segments[targetLocale][index].target = item.msgstr[0];
+            });
+        });
+    });
+    const request = {
+        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----------`);
+    });
+}
+// 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) {
+    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.default.readFileSync(path).toString();
+        const po = _pofile.default.parse(raw);
+        po.items.filter((item)=>!item["obsolete"]).forEach((item)=>{
+            const newSegment = createSegmentFromPoItem(item);
+            segments.push(newSegment);
+        });
+    });
+    const request = {
+        client: "lingui",
+        version: require("@lingui/core/package.json").version,
+        source_language: sourceLocale,
+        target_languages: targetLocales,
+        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 itemHasId = item.msgid != item.msgstr[0] && item.msgstr[0].length;
+    const segment = {
+        type: "source",
+        source: itemHasId ? item.msgstr[0] : item.msgid,
+        context: "",
+        references: [],
+        comment: ""
+    };
+    if (itemHasId) {
+        segment.context = item.msgid;
+    }
+    if (item.references.length) {
+        segment.references = item.references;
+    }
+    if (item.extractedComments.length) {
+        segment.comment = item.extractedComments.join(" | ");
+    }
+    return segment;
+}
+function createPoItemFromSegment(segment) {
+    const item = new _pofile.default.Item();
+    item.msgid = segment.context ? segment.context : segment.source;
+    item.msgstr = [
+        segment.target
+    ];
+    item.references = segment.references && segment.references.length ? segment.references : [];
+    item.extractedComments = segment.comment ? segment.comment.split(" | ") : [];
+    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.dirname)(path);
+            // Remove PO, JS and empty dir
+            if (_fs.default.existsSync(path)) {
+                _fs.default.unlinkSync(path);
+            }
+            if (_fs.default.existsSync(jsPath)) {
+                _fs.default.unlinkSync(jsPath);
+            }
+            if (_fs.default.existsSync(dirPath) && _fs.default.readdirSync(dirPath).length === 0) {
+                _fs.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.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.default.promises.mkdir((0, _path.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);
+                }
+            });
+        });
+    });
+}
+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(_glob.default.sync(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.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();
+}

package/dist/tests.js

@@ -0,0 +1,137 @@
+"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, {
+    copyFixture: ()=>copyFixture,
+    defaultMakeOptions: ()=>defaultMakeOptions,
+    defaultMakeTemplateOptions: ()=>defaultMakeTemplateOptions,
+    defaultMergeOptions: ()=>defaultMergeOptions,
+    normalizeLineEndings: ()=>normalizeLineEndings,
+    makeCatalog: ()=>makeCatalog,
+    makePrevMessage: ()=>makePrevMessage,
+    makeNextMessage: ()=>makeNextMessage,
+    listingToHumanReadable: ()=>listingToHumanReadable,
+    createFixtures: ()=>createFixtures,
+    readFsToJson: ()=>readFsToJson
+});
+const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _catalog = require("./api/catalog");
+const _conf = require("@lingui/conf");
+const _api = require("./api");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function copyFixture(fixtureDir) {
+    const tmpDir = await _fs.default.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), `lingui-test-${process.pid}`));
+    try {
+        await _fs.default.promises.cp(fixtureDir, tmpDir, {
+            recursive: true
+        });
+    } catch (err) {
+        if (err.code != "ENOENT") {
+            throw err;
+        }
+    }
+    return tmpDir;
+}
+const defaultMakeOptions = {
+    verbose: false,
+    clean: false,
+    overwrite: false,
+    locale: null,
+    prevFormat: null,
+    orderBy: "messageId"
+};
+const defaultMakeTemplateOptions = {
+    verbose: false,
+    orderBy: "messageId"
+};
+const defaultMergeOptions = {
+    overwrite: false
+};
+const normalizeLineEndings = (str)=>str.replace(/\r?\n/g, "\r\n");
+const makeCatalog = async (_config = {})=>{
+    const config = (0, _conf.makeConfig)(_config, {
+        skipValidation: true
+    });
+    return new _catalog.Catalog({
+        name: "messages",
+        path: "{locale}/messages",
+        include: [],
+        exclude: [],
+        format: await (0, _api.getFormat)(config.format, config.formatOptions, config.sourceLocale)
+    }, config);
+};
+function makePrevMessage(message = {}) {
+    return {
+        translation: "",
+        ...makeNextMessage(message)
+    };
+}
+function makeNextMessage(message = {}) {
+    return {
+        origin: [
+            [
+                "catalog.test.ts",
+                1
+            ]
+        ],
+        obsolete: false,
+        ...message
+    };
+}
+function listingToHumanReadable(listing) {
+    const output = [];
+    Object.entries(listing).forEach(([filename, value])=>{
+        if (typeof value === "string") {
+            output.push("#######################");
+            output.push(`Filename: ${filename}`);
+            output.push("#######################");
+            output.push("");
+            output.push(normalizeLineEndings(value));
+            output.push("");
+        } else {
+            output.push(...listingToHumanReadable(value));
+        }
+    });
+    return output.join("\n");
+}
+async function createFixtures(listing) {
+    const tmpDir = await _fs.default.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), `lingui-test-${process.pid}`));
+    async function create(listing) {
+        for (const [filename, value] of Object.entries(listing)){
+            if (typeof value === "string") {
+                await _fs.default.promises.writeFile(_path.default.join(tmpDir, filename), value);
+            } else {
+                await create(value);
+            }
+        }
+    }
+    await create(listing);
+    return tmpDir;
+}
+function readFsToJson(directory, filter) {
+    const out = {};
+    _fs.default.readdirSync(directory).map((filename)=>{
+        const filepath = _path.default.join(directory, filename);
+        if (_fs.default.lstatSync(filepath).isDirectory()) {
+            out[filename] = readFsToJson(filepath);
+            return out;
+        }
+        if (!filter || filter(filename)) {
+            out[filename] = _fs.default.readFileSync(filepath).toString();
+        }
+    });
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingui/cli",
-  "version": "4.0.0-next.4",
+  "version": "4.0.0-next.5",
   "description": "CLI for working wit message catalogs",
   "keywords": [
     "cli",
@@ -18,31 +18,34 @@
     "name": "Tomáš Ehrlich",
     "email": "tomas.ehrlich@gmail.com"
   },
-  "main": "./build/lingui.js",
+  "main": "./dist/lingui.js",
   "bin": {
-    "lingui": "./build/lingui.js"
+    "lingui": "./dist/lingui.js"
   },
   "exports": {
     ".": {
-      "require": "./build/lingui.js"
+      "require": "./dist/lingui.js"
     },
     "./api": {
-      "require": "./build/api/index.js"
+      "require": "./dist/api/index.js"
     },
     "./api/extractors/babel": {
-      "require": "./build/api/extractors/babel.js"
+      "require": "./dist/api/extractors/babel.js"
     },
     "./api/extractors/typescript": {
-      "require": "./build/api/extractors/typescript.js"
+      "require": "./dist/api/extractors/typescript.js"
     }
   },
+  "scripts": {
+    "build": "rimraf ./dist && swc ./src -d dist"
+  },
   "engines": {
     "node": ">=16.0.0"
   },
   "files": [
     "LICENSE",
     "README.md",
-    "build/"
+    "dist/"
   ],
   "dependencies": {
     "@babel/core": "^7.21.0",
@@ -50,10 +53,11 @@
     "@babel/parser": "^7.21.2",
     "@babel/runtime": "^7.21.0",
     "@babel/types": "^7.21.2",
-    "@lingui/babel-plugin-extract-messages": "^4.0.0-next.4",
-    "@lingui/conf": "^4.0.0-next.4",
-    "@lingui/core": "^4.0.0-next.4",
-    "@lingui/format-po": "^4.0.0-next.4",
+    "@lingui/babel-plugin-extract-messages": "^4.0.0-next.5",
+    "@lingui/conf": "^4.0.0-next.5",
+    "@lingui/core": "^4.0.0-next.5",
+    "@lingui/format-po": "^4.0.0-next.5",
+    "@lingui/message-utils": "^4.0.0-next.5",
     "babel-plugin-macros": "^3.0.1",
     "chalk": "^4.1.0",
     "chokidar": "3.5.1",
@@ -75,11 +79,13 @@
   },
   "devDependencies": {
     "@lingui/jest-mocks": "^3.0.3",
+    "@swc/cli": "^0.1.62",
+    "@swc/core": "^1.3.42",
     "@types/convert-source-map": "^2.0.0",
     "@types/micromatch": "^4.0.1",
     "@types/normalize-path": "^3.0.0",
     "mock-fs": "^5.2.0",
     "mockdate": "^3.0.5"
   },
-  "gitHead": "3b999e35d26e67dec7cf0591f794be782e11022c"
+  "gitHead": "bdbd6cf310cbcf09e1fe288f20ef530c28de481d"
 }

package/build/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017-2022 Tomáš Ehrlich, (c) 2022-2023 Crowdin.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/build/api/catalog/extractFromFiles.js

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

package/build/api/catalog/getCatalogs.js

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