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

package/dist/api/catalog/extractFromFiles.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "extractFromFiles", {
+    enumerable: true,
+    get: ()=>extractFromFiles
+});
+const _extractors = /*#__PURE__*/ _interopRequireDefault(require("../extractors"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _chalk = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+const _utils = require("../utils");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 &&= fileSuccess;
+    }
+    if (!catalogSuccess) return undefined;
+    return messages;
+}

package/dist/api/catalog/getCatalogs.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, {
+    getCatalogs: ()=>getCatalogs,
+    getCatalogForMerge: ()=>getCatalogForMerge,
+    getCatalogForFile: ()=>getCatalogForFile
+});
+const _glob = /*#__PURE__*/ _interopRequireDefault(require("glob"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _catalog = require("../catalog");
+const _utils = require("../utils");
+const _micromatch = /*#__PURE__*/ _interopRequireDefault(require("micromatch"));
+const _formats = require("../formats");
+const _getExperimentalCatalogs = require("../../extract-experimental/getExperimentalCatalogs");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const NAME_PH = "{name}";
+const LOCALE_PH = "{locale}";
+async function getCatalogs(config) {
+    var _config_experimental, _config_experimental_extractor;
+    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 ? void 0 : (_config_experimental_extractor = _config_experimental.extractor) === null || _config_experimental_extractor === void 0 ? void 0 : _config_experimental_extractor.entries.length) {
+        catalogs.push(...await (0, _getExperimentalCatalogs.getExperimentalCatalogs)(config));
+    }
+    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
+    ];
+};
+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;
+}

package/dist/api/catalog/getTranslationsForCatalog.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTranslationsForCatalog", {
+    enumerable: true,
+    get: ()=>getTranslationsForCatalog
+});
+async function getTranslationsForCatalog(catalog, locale, options) {
+    const catalogs = await catalog.readAll();
+    const template = await catalog.readTemplate() || {};
+    const sourceLocaleCatalog = catalogs[options.sourceLocale] || {};
+    const input = {
+        ...template,
+        ...sourceLocaleCatalog,
+        ...catalogs[locale]
+    };
+    return Object.keys(input).reduce((acc, key)=>{
+        acc[key] = getTranslation(catalogs, input[key], locale, key, options);
+        return acc;
+    }, {});
+}
+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 _localeCatalog_key;
+        const localeCatalog = catalogs[_locale];
+        return localeCatalog === null || localeCatalog === void 0 ? void 0 : (_localeCatalog_key = localeCatalog[key]) === null || _localeCatalog_key === void 0 ? void 0 : _localeCatalog_key.translation;
+    };
+    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.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mergeCatalog", {
+    enumerable: true,
+    get: ()=>mergeCatalog
+});
+const _ramda = /*#__PURE__*/ _interopRequireWildcard(require("ramda"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function mergeCatalog(prevCatalog, nextCatalog, forSourceLocale, options) {
+    const nextKeys = Object.keys(nextCatalog);
+    const prevKeys = _ramda.keys(prevCatalog).map(String);
+    const newKeys = _ramda.difference(nextKeys, prevKeys);
+    const mergeKeys = _ramda.intersection(nextKeys, prevKeys);
+    const obsoleteKeys = _ramda.difference(prevKeys, nextKeys);
+    // Initialize new catalog with new keys
+    const newMessages = _ramda.mapObjIndexed((message, key)=>({
+            translation: forSourceLocale ? message.message || key : "",
+            ...message
+        }), _ramda.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]: {
+                translation,
+                ..._ramda.omit([
+                    "obsolete, translation"
+                ], nextCatalog[key])
+            }
+        };
+    });
+    // Mark all remaining translations as obsolete
+    // Only if *options.files* is not provided
+    const obsoleteMessages = obsoleteKeys.map((key)=>({
+            [key]: {
+                ...prevCatalog[key],
+                obsolete: !options.files
+            }
+        }));
+    return _ramda.mergeAll([
+        newMessages,
+        ...mergedMessages,
+        ...obsoleteMessages
+    ]);
+}

package/dist/api/catalog.js

@@ -0,0 +1,286 @@
+"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, {
+    Catalog: ()=>Catalog,
+    cleanObsolete: ()=>cleanObsolete,
+    order: ()=>order,
+    orderByMessage: ()=>orderByMessage
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _ramda = /*#__PURE__*/ _interopRequireWildcard(require("ramda"));
+const _glob = /*#__PURE__*/ _interopRequireDefault(require("glob"));
+const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
+const _getTranslationsForCatalog = require("./catalog/getTranslationsForCatalog");
+const _mergeCatalog = require("./catalog/mergeCatalog");
+const _extractFromFiles = require("./catalog/extractFromFiles");
+const _utils = require("./utils");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const LOCALE = "{locale}";
+const LOCALE_SUFFIX_RE = /\{locale\}.*$/;
+class Catalog {
+    config;
+    name;
+    path;
+    include;
+    exclude;
+    format;
+    templateFile;
+    constructor({ name , path , include , templatePath , format , exclude =[]  }, config){
+        this.config = config;
+        this.name = name;
+        this.path = (0, _utils.normalizeRelativePath)(path);
+        this.include = include.map(_utils.normalizeRelativePath);
+        this.exclude = [
+            this.localeDir,
+            ...exclude.map(_utils.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 = _ramda.map(_ramda.pipe(// Clean obsolete messages
+        options.clean ? cleanObsolete : _ramda.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, _normalizePath.default)(p, false));
+            const regex = new RegExp(options.files.join("|"), "i");
+            paths = paths.filter((path)=>regex.test(path));
+        }
+        return await (0, _extractFromFiles.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 _ramda.mapObjIndexed((prevCatalog, locale)=>{
+            return (0, _mergeCatalog.mergeCatalog)(prevCatalog, nextCatalog, this.config.sourceLocale === locale, options);
+        }, prevCatalogs);
+    }
+    async getTranslations(locale, options) {
+        return await (0, _getTranslationsForCatalog.getTranslationsForCatalog)(this, locale, options);
+    }
+    async write(locale, messages) {
+        const filename = (0, _utils.replacePlaceholders)(this.path, {
+            locale
+        }) + this.format.getCatalogExtension();
+        const created = !_fs.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.replacePlaceholders)(this.path, {
+            locale
+        })}.${ext}`;
+        await (0, _utils.writeFile)(filename, compiledCatalog);
+        return filename;
+    }
+    async read(locale) {
+        const filename = (0, _utils.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.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, _normalizePath.default)(_path.default.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*")) : includePath;
+        });
+        const patterns = includeGlobs.length > 1 ? `{${includeGlobs.join(",")}}` : includeGlobs[0];
+        return _glob.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;
+    }
+}
+function getTemplatePath(ext, path) {
+    return path.replace(LOCALE_SUFFIX_RE, "messages" + ext);
+}
+const cleanObsolete = _ramda.filter((message)=>!message.obsolete);
+function order(by) {
+    return ({
+        messageId: orderByMessageId,
+        message: orderByMessage,
+        origin: orderByOrigin
+    })[by];
+}
+/**
+ * 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;
+    }, {});
+}