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

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

@@ -0,0 +1,47 @@
+"use strict";
+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_1.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_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_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] = 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,
+        });
+        catalogSuccess && (catalogSuccess = fileSuccess);
+    }
+    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

@@ -0,0 +1,129 @@
+"use strict";
+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 _a, _b;
+    const catalogsConfig = config.catalogs;
+    const catalogs = [];
+    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_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));
+            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_1.Catalog({
+                name: getCatalogName(catalog.path),
+                path: (0, utils_1.normalizeRelativePath)(catalog.path),
+                include,
+                exclude,
+                format,
+            }, config));
+            return;
+        }
+        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,
+        });
+        candidates.forEach((catalogDir) => {
+            const name = path_1.default.basename(catalogDir);
+            catalogs.push(new catalog_1.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 })),
+                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)));
+    }
+    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];
+};
+/**
+ * Create catalog for merged messages.
+ */
+async function getCatalogForMerge(config) {
+    const format = await (0, formats_1.getFormat)(config.format, config.formatOptions, config.sourceLocale);
+    validateCatalogPath(config.catalogsMergePath, format.getCatalogExtension());
+    return new catalog_1.Catalog({
+        name: getCatalogName(config.catalogsMergePath),
+        path: (0, utils_1.normalizeRelativePath)(config.catalogsMergePath),
+        include: [],
+        exclude: [],
+        format,
+    }, config);
+}
+exports.getCatalogForMerge = getCatalogForMerge;
+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 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,
+            };
+        }
+    }
+    return null;
+}
+exports.getCatalogForFile = getCatalogForFile;
+/**
+ *  Validate that `catalogPath` doesn't end with trailing slash
+ */
+function validateCatalogPath(path, extension) {
+    if (!path.endsWith(utils_1.PATHSEP)) {
+        return;
+    }
+    const correctPath = path.slice(0, -1);
+    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}".`);
+}
+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;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+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 sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
+    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;
+    }
+    return catalog[key].translation || catalog[key].message;
+}
+function getTranslation(catalogs, msg, locale, key, options) {
+    const { fallbackLocales, sourceLocale, onMissing } = 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;
+    };
+    const getMultipleFallbacks = (_locale) => {
+        const fL = fallbackLocales && (fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales[_locale]);
+        // some probably the fallback will be undefined, so just search by locale
+        if (!fL)
+            return null;
+        if (Array.isArray(fL)) {
+            for (const fallbackLocale of fL) {
+                if (catalogs[fallbackLocale] && getTranslation(fallbackLocale)) {
+                    return getTranslation(fallbackLocale);
+                }
+            }
+        }
+        else {
+            return getTranslation(fL);
+        }
+    };
+    // target locale -> fallback locales -> fallback locales default ->
+    // ** (following fallbacks would emit `missing` warning) **
+    // -> source locale translation -> source locale message
+    // -> template message
+    // ** last resort **
+    // -> id
+    let translation = 
+    // Get translation in target locale
+    getTranslation(locale) ||
+        // We search in fallbackLocales as dependent of each locale
+        getMultipleFallbacks(locale) ||
+        // Get translation in fallbackLocales.default (if any)
+        ((fallbackLocales === null || fallbackLocales === void 0 ? void 0 : fallbackLocales.default) && getTranslation(fallbackLocales.default)) ||
+        (sourceLocale &&
+            sourceLocale === locale &&
+            sourceLocaleFallback(catalogs[sourceLocale], key));
+    if (!translation) {
+        onMissing &&
+            onMissing({
+                id: key,
+                source: msg.message || sourceLocaleFallback(catalogs[sourceLocale], key),
+            });
+    }
+    return (translation ||
+        (sourceLocale && sourceLocaleFallback(catalogs[sourceLocale], key)) ||
+        // take from template
+        msg.message ||
+        key);
+}

package/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

@@ -0,0 +1,55 @@
+"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 (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 = R.keys(prevCatalog).map(String);
+    const newKeys = R.difference(nextKeys, prevKeys);
+    const mergeKeys = R.intersection(nextKeys, prevKeys);
+    const obsoleteKeys = R.difference(prevKeys, nextKeys);
+    // Initialize new catalog with new keys
+    const newMessages = R.mapObjIndexed((message, key) => (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;
+        return {
+            [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]: 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;

package/dist/api/catalog.js

@@ -0,0 +1,261 @@
+"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 (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderByMessage = exports.order = exports.cleanObsolete = exports.Catalog = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const R = __importStar(require("ramda"));
+const glob_1 = __importDefault(require("glob"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
+const getTranslationsForCatalog_1 = require("./catalog/getTranslationsForCatalog");
+const mergeCatalog_1 = require("./catalog/mergeCatalog");
+const extractFromFiles_1 = require("./catalog/extractFromFiles");
+const utils_1 = require("./utils");
+const LOCALE = "{locale}";
+const LOCALE_SUFFIX_RE = /\{locale\}.*$/;
+class Catalog {
+    constructor({ name, path, include, templatePath, format, exclude = [] }, config) {
+        this.config = config;
+        this.name = name;
+        this.path = (0, utils_1.normalizeRelativePath)(path);
+        this.include = include.map(utils_1.normalizeRelativePath);
+        this.exclude = [this.localeDir, ...exclude.map(utils_1.normalizeRelativePath)];
+        this.format = format;
+        this.templateFile =
+            templatePath ||
+                getTemplatePath(this.format.getTemplateExtension(), this.path);
+    }
+    async make(options) {
+        const nextCatalog = await this.collect({ files: options.files });
+        if (!nextCatalog)
+            return false;
+        const prevCatalogs = await this.readAll();
+        const catalogs = this.merge(prevCatalogs, nextCatalog, {
+            overwrite: options.overwrite,
+            files: options.files,
+        });
+        // Map over all locales and post-process each catalog
+        const cleanAndSort = R.map(R.pipe(
+        // Clean obsolete messages
+        (options.clean ? exports.cleanObsolete : R.identity), 
+        // Sort messages
+        order(options.orderBy)));
+        const sortedCatalogs = cleanAndSort(catalogs);
+        const locales = options.locale ? [options.locale] : this.locales;
+        await Promise.all(locales.map((locale) => this.write(locale, sortedCatalogs[locale])));
+        return sortedCatalogs;
+    }
+    async makeTemplate(options) {
+        const catalog = await this.collect({ files: options.files });
+        if (!catalog)
+            return false;
+        const sorted = order(options.orderBy)(catalog);
+        await this.writeTemplate(sorted);
+        return sorted;
+    }
+    /**
+     * Collect messages from source paths. Return a raw message catalog as JSON.
+     */
+    async collect(options = {}) {
+        let paths = this.sourcePaths;
+        if (options.files) {
+            options.files = options.files.map((p) => (0, normalize_path_1.default)(p, false));
+            const regex = new RegExp(options.files.join("|"), "i");
+            paths = paths.filter((path) => regex.test(path));
+        }
+        return await (0, extractFromFiles_1.extractFromFiles)(paths, this.config);
+    }
+    /*
+     *
+     * prevCatalogs - map of message catalogs in all available languages with translations
+     * nextCatalog - language-agnostic catalog with collected messages
+     *
+     * Note: if a catalog in prevCatalogs is null it means the language is available, but
+     * no previous catalog was generated (usually first run).
+     *
+     * Orthogonal use-cases
+     * --------------------
+     *
+     * Message IDs:
+     * - auto-generated IDs: message is used as a key, `defaults` is not set
+     * - custom IDs: message is used as `defaults`, custom ID as a key
+     *
+     * Source locale (defined by `sourceLocale` in config):
+     * - catalog for `sourceLocale`: initially, `translation` is prefilled with `defaults`
+     *   (for custom IDs) or `key` (for auto-generated IDs)
+     * - all other languages: translation is kept empty
+     */
+    merge(prevCatalogs, nextCatalog, options) {
+        return R.mapObjIndexed((prevCatalog, locale) => {
+            return (0, mergeCatalog_1.mergeCatalog)(prevCatalog, nextCatalog, this.config.sourceLocale === locale, options);
+        }, prevCatalogs);
+    }
+    async getTranslations(locale, options) {
+        return await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(this, locale, options);
+    }
+    async write(locale, messages) {
+        const filename = (0, utils_1.replacePlaceholders)(this.path, { locale }) +
+            this.format.getCatalogExtension();
+        const created = !fs_1.default.existsSync(filename);
+        await this.format.write(filename, messages, locale);
+        return [created, filename];
+    }
+    async writeTemplate(messages) {
+        const filename = this.templateFile;
+        await this.format.write(filename, messages, undefined);
+    }
+    async writeCompiled(locale, compiledCatalog, namespace) {
+        let ext;
+        if (namespace === "es") {
+            ext = "mjs";
+        }
+        else if (namespace === "ts") {
+            ext = "ts";
+        }
+        else {
+            ext = "js";
+        }
+        const filename = `${(0, utils_1.replacePlaceholders)(this.path, { locale })}.${ext}`;
+        await (0, utils_1.writeFile)(filename, compiledCatalog);
+        return filename;
+    }
+    async read(locale) {
+        const filename = (0, utils_1.replacePlaceholders)(this.path, { locale }) +
+            this.format.getCatalogExtension();
+        return await this.format.read(filename, locale);
+    }
+    async readAll() {
+        const res = {};
+        await Promise.all(this.locales.map(async (locale) => (res[locale] = await this.read(locale))));
+        // statement above will save locales in object in undetermined order
+        // resort here to have keys order the same as in locales definition
+        return this.locales.reduce((acc, locale) => {
+            acc[locale] = res[locale];
+            return acc;
+        }, {});
+    }
+    async readTemplate() {
+        const filename = this.templateFile;
+        return await this.format.read(filename, undefined);
+    }
+    get sourcePaths() {
+        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.
+             * On windows, this will by default result in /foo/* matching C:\foo\bar.txt.
+             */
+            return isDir
+                ? (0, normalize_path_1.default)(path_1.default.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*"))
+                : includePath;
+        });
+        const patterns = includeGlobs.length > 1 ? `{${includeGlobs.join(",")}}` : includeGlobs[0];
+        return glob_1.default.sync(patterns, { ignore: this.exclude, mark: true });
+    }
+    get localeDir() {
+        const localePatternIndex = this.path.indexOf(LOCALE);
+        if (localePatternIndex === -1) {
+            throw Error(`Invalid catalog path: ${LOCALE} variable is missing`);
+        }
+        return this.path.substr(0, localePatternIndex);
+    }
+    get locales() {
+        return this.config.locales;
+    }
+}
+exports.Catalog = Catalog;
+function getTemplatePath(ext, path) {
+    return path.replace(LOCALE_SUFFIX_RE, "messages" + ext);
+}
+exports.cleanObsolete = R.filter((message) => !message.obsolete);
+function order(by) {
+    return {
+        messageId: orderByMessageId,
+        message: orderByMessage,
+        origin: orderByOrigin,
+    }[by];
+}
+exports.order = order;
+/**
+ * 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()
+        .reduce((acc, key) => {
+        ;
+        acc[key] = messages[key];
+        return acc;
+    }, {});
+}
+function orderByOrigin(messages) {
+    function getFirstOrigin(messageKey) {
+        const sortedOrigins = messages[messageKey].origin.sort((a, b) => {
+            if (a[0] < b[0])
+                return -1;
+            if (a[0] > b[0])
+                return 1;
+            return 0;
+        });
+        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;
+    }, {});
+}
+function orderByMessage(messages) {
+    return Object.keys(messages)
+        .sort((a, b) => {
+        const aMsg = messages[a].message || "";
+        const bMsg = messages[b].message || "";
+        return aMsg.localeCompare(bMsg);
+    })
+        .reduce((acc, key) => {
+        ;
+        acc[key] = messages[key];
+        return acc;
+    }, {});
+}
+exports.orderByMessage = orderByMessage;