@messagevisor/catalog 0.0.1 → 0.2.0

package/lib/node/index.js

@@ -0,0 +1,1755 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATALOG_HISTORY_PAGE_SIZE = exports.CATALOG_SCHEMA_VERSION = void 0;
+exports.exportCatalog = exportCatalog;
+exports.serveCatalog = serveCatalog;
+exports.createCatalogApi = createCatalogApi;
+exports.createCatalogPlugin = createCatalogPlugin;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var childProcess = __importStar(require("child_process"));
+var fs = __importStar(require("fs"));
+var http = __importStar(require("http"));
+var path = __importStar(require("path"));
+var formatExamplePreview_1 = require("./formatExamplePreview");
+exports.CATALOG_SCHEMA_VERSION = "1";
+exports.CATALOG_HISTORY_PAGE_SIZE = 50;
+function toPosixPath(value) {
+    return value.split(path.sep).join("/");
+}
+function getRealPath(value) {
+    try {
+        return fs.realpathSync.native(value);
+    }
+    catch (_error) {
+        return value;
+    }
+}
+function encodeKey(key) {
+    return encodeURIComponent(key);
+}
+function matchesPattern(key, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    return patterns.some(function (pattern) {
+        var escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        return new RegExp("^".concat(escaped, "$")).test(key);
+    });
+}
+function readAll(keys, read) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, _i, keys_1, key, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    result = {};
+                    _i = 0, keys_1 = keys;
+                    _c.label = 1;
+                case 1:
+                    if (!(_i < keys_1.length)) return [3 /*break*/, 4];
+                    key = keys_1[_i];
+                    _a = result;
+                    _b = key;
+                    return [4 /*yield*/, read(key)];
+                case 2:
+                    _a[_b] = _c.sent();
+                    _c.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, result];
+            }
+        });
+    });
+}
+function sortStrings(values) {
+    return Array.from(new Set(values)).sort();
+}
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function getLocaleDirections(locales) {
+    return Object.fromEntries(Object.entries(locales).map(function (_a) {
+        var localeKey = _a[0], locale = _a[1];
+        return [localeKey, locale.direction];
+    }));
+}
+function collectAttributeKeysFromConditions(condition, result) {
+    if (!condition || condition === "*") {
+        return;
+    }
+    if (Array.isArray(condition)) {
+        for (var _i = 0, condition_1 = condition; _i < condition_1.length; _i++) {
+            var item = condition_1[_i];
+            collectAttributeKeysFromConditions(item, result);
+        }
+        return;
+    }
+    if (typeof condition === "string") {
+        return;
+    }
+    if ("attribute" in condition) {
+        result.add(condition.attribute);
+        return;
+    }
+    if ("and" in condition) {
+        collectAttributeKeysFromConditions(condition.and, result);
+    }
+    if ("or" in condition) {
+        collectAttributeKeysFromConditions(condition.or, result);
+    }
+    if ("not" in condition) {
+        collectAttributeKeysFromConditions(condition.not, result);
+    }
+}
+function collectSegmentKeys(segments, result) {
+    if (!segments || segments === "*") {
+        return;
+    }
+    if (typeof segments === "string") {
+        result.add(segments);
+        return;
+    }
+    if (Array.isArray(segments)) {
+        for (var _i = 0, segments_1 = segments; _i < segments_1.length; _i++) {
+            var segment = segments_1[_i];
+            collectSegmentKeys(segment, result);
+        }
+        return;
+    }
+    if ("and" in segments) {
+        collectSegmentKeys(segments.and, result);
+    }
+    if ("or" in segments) {
+        collectSegmentKeys(segments.or, result);
+    }
+    if ("not" in segments) {
+        collectSegmentKeys(segments.not, result);
+    }
+}
+function getTargetMessageKeys(target, messageKeys) {
+    var _a;
+    var includeMessages = ((_a = target.includeMessages) === null || _a === void 0 ? void 0 : _a.length) ? target.includeMessages : ["*"];
+    var excludeMessages = target.excludeMessages || [];
+    return messageKeys
+        .filter(function (messageKey) {
+        return matchesPattern(messageKey, includeMessages) && !matchesPattern(messageKey, excludeMessages);
+    })
+        .sort();
+}
+function getHistoryEntityKey(type, key, set) {
+    return "".concat(set || "", "\u001F").concat(type, "\u001F").concat(key);
+}
+function toLastModified(entry) {
+    return {
+        commit: entry.commit,
+        author: entry.author,
+        timestamp: entry.timestamp,
+    };
+}
+function getLastModified(historyIndex, type, key, set) {
+    return historyIndex.lastModifiedByEntity[getHistoryEntityKey(type, key, set)];
+}
+function getEntitySummary(entity, type, key, historyIndex, set, extra) {
+    if (extra === void 0) { extra = {}; }
+    return __assign(__assign({ key: key, description: entity.description, archived: entity.archived, deprecated: entity.deprecated }, extra), { lastModified: getLastModified(historyIndex, type, key, set), href: "entities/".concat(type, "/").concat(encodeKey(key), ".json") });
+}
+function getPathValue(value, segments) {
+    var current = value;
+    for (var _i = 0, segments_2 = segments; _i < segments_2.length; _i++) {
+        var segment = segments_2[_i];
+        if (!current || typeof current !== "object" || !(segment in current)) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function flattenObjectRows(value, prefix) {
+    if (prefix === void 0) { prefix = ""; }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return prefix ? [{ path: prefix, value: value }] : [];
+    }
+    var rows = [];
+    for (var _i = 0, _a = Object.keys(value).sort(); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var childPath = prefix ? "".concat(prefix, ".").concat(key) : key;
+        var childValue = value[key];
+        if (childValue && typeof childValue === "object" && !Array.isArray(childValue)) {
+            rows.push.apply(rows, flattenObjectRows(childValue, childPath));
+        }
+        else {
+            rows.push({ path: childPath, value: childValue });
+        }
+    }
+    return rows;
+}
+function resolveLocaleChain(localeKey, locales, field) {
+    var _a;
+    var chain = [];
+    var seen = new Set();
+    var currentKey = localeKey;
+    while (currentKey && !seen.has(currentKey)) {
+        seen.add(currentKey);
+        chain.unshift(currentKey);
+        currentKey = (_a = locales[currentKey]) === null || _a === void 0 ? void 0 : _a[field];
+    }
+    return chain;
+}
+function getLocaleFormatSource(localeKey, locales, formatPath) {
+    var _a, _b;
+    var pathSegments = formatPath.split(".");
+    if (typeof getPathValue((_a = locales[localeKey]) === null || _a === void 0 ? void 0 : _a.formats, pathSegments) !== "undefined") {
+        return { source: "direct" };
+    }
+    var chain = resolveLocaleChain(localeKey, locales, "inheritFormatsFrom").reverse();
+    for (var _i = 0, chain_1 = chain; _i < chain_1.length; _i++) {
+        var candidate = chain_1[_i];
+        if (candidate !== localeKey &&
+            typeof getPathValue((_b = locales[candidate]) === null || _b === void 0 ? void 0 : _b.formats, pathSegments) !== "undefined") {
+            return { source: "inherited", from: candidate };
+        }
+    }
+    return { source: "missing" };
+}
+function getFormatRows(runtime, localeKey, locales, target) {
+    var computedFormats = runtime.resolveFormats(localeKey, locales, target) || {};
+    var rows = flattenObjectRows(computedFormats).map(function (row) {
+        var _a;
+        if (target &&
+            typeof getPathValue((_a = target.formats) === null || _a === void 0 ? void 0 : _a[localeKey], row.path.split(".")) !== "undefined") {
+            return __assign(__assign({}, row), { source: "target", from: "target" });
+        }
+        return __assign(__assign({}, row), getLocaleFormatSource(localeKey, locales, row.path));
+    });
+    return (0, formatExamplePreview_1.attachFormatExamplePreviews)(localeKey, computedFormats, rows);
+}
+function resolveTranslationRow(translations, localeKey, locales) {
+    if (typeof (translations === null || translations === void 0 ? void 0 : translations[localeKey]) !== "undefined") {
+        return {
+            locale: localeKey,
+            value: translations[localeKey],
+            source: "direct",
+        };
+    }
+    var chain = resolveLocaleChain(localeKey, locales, "inheritTranslationsFrom").reverse();
+    for (var _i = 0, chain_2 = chain; _i < chain_2.length; _i++) {
+        var candidate = chain_2[_i];
+        if (candidate !== localeKey && typeof (translations === null || translations === void 0 ? void 0 : translations[candidate]) !== "undefined") {
+            return {
+                locale: localeKey,
+                value: translations[candidate],
+                source: "inherited",
+                from: candidate,
+            };
+        }
+    }
+    return {
+        locale: localeKey,
+        value: "",
+        source: "missing",
+    };
+}
+function getDuplicateSetKey(set) {
+    return set || "root";
+}
+function toLocaleDuplicatesFile(localeKey, duplicatesByLocale) {
+    var _a;
+    var duplicateValues = ((_a = duplicatesByLocale[localeKey]) === null || _a === void 0 ? void 0 : _a.duplicateValues) || [];
+    return {
+        locale: localeKey,
+        summary: {
+            duplicateValues: duplicateValues.length,
+            duplicateMessageKeys: duplicateValues.reduce(function (sum, duplicate) { return sum + duplicate.messageKeys.length; }, 0),
+        },
+        duplicateValues: duplicateValues,
+    };
+}
+function writeJson(filePath, content) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fs.promises.mkdir(path.dirname(filePath), { recursive: true })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, fs.promises.writeFile(filePath, JSON.stringify(content, null, 2))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function getEntityDirectoryPaths(config) {
+    return {
+        locale: config.localesDirectoryPath,
+        message: config.messagesDirectoryPath,
+        attribute: config.attributesDirectoryPath,
+        segment: config.segmentsDirectoryPath,
+        target: config.targetsDirectoryPath,
+        test: config.testsDirectoryPath,
+    };
+}
+function getKeyFromRelativeEntityPath(relativePath, extension, namespaceCharacter) {
+    var withoutExtension = relativePath.slice(0, -extension.length);
+    var parts = withoutExtension.split(path.sep);
+    var last = parts[parts.length - 1];
+    if (last.endsWith(".spec")) {
+        parts[parts.length - 1] = last.slice(0, -".spec".length);
+    }
+    return parts.join(namespaceCharacter);
+}
+function getEntityInfoFromRelativePath(rootDirectoryPath, projectConfig, relativePath) {
+    var absolutePath = path.join(rootDirectoryPath, relativePath);
+    var extension = ".".concat(projectConfig.parser.extension);
+    var configs = projectConfig.sets
+        ? fs.existsSync(projectConfig.setsDirectoryPath)
+            ? fs
+                .readdirSync(projectConfig.setsDirectoryPath, { withFileTypes: true })
+                .filter(function (entry) { return entry.isDirectory(); })
+                .map(function (entry) { return ({
+                set: entry.name,
+                directories: getEntityDirectoryPaths(__assign(__assign({}, projectConfig), { localesDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "locales"), messagesDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "messages"), attributesDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "attributes"), segmentsDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "segments"), targetsDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "targets"), testsDirectoryPath: path.join(projectConfig.setsDirectoryPath, entry.name, "tests") })),
+            }); })
+            : []
+        : [{ set: undefined, directories: getEntityDirectoryPaths(projectConfig) }];
+    for (var _i = 0, configs_1 = configs; _i < configs_1.length; _i++) {
+        var config = configs_1[_i];
+        for (var _a = 0, _b = Object.keys(config.directories); _a < _b.length; _a++) {
+            var type = _b[_a];
+            var directoryPath = config.directories[type];
+            if (absolutePath === directoryPath ||
+                !absolutePath.startsWith("".concat(directoryPath).concat(path.sep)) ||
+                !absolutePath.endsWith(extension)) {
+                continue;
+            }
+            return {
+                type: type,
+                key: getKeyFromRelativeEntityPath(path.relative(directoryPath, absolutePath), extension, projectConfig.namespaceCharacter),
+                set: config.set,
+            };
+        }
+    }
+    return undefined;
+}
+function runGit(rootDirectoryPath, args) {
+    return childProcess.execFileSync("git", __spreadArray(["-C", rootDirectoryPath], args, true), {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+}
+function getCatalogHistoryPathPatterns(rootDirectoryPath, projectConfig) {
+    return projectConfig.sets
+        ? [path.relative(rootDirectoryPath, projectConfig.setsDirectoryPath)]
+        : [
+            path.relative(rootDirectoryPath, projectConfig.localesDirectoryPath),
+            path.relative(rootDirectoryPath, projectConfig.messagesDirectoryPath),
+            path.relative(rootDirectoryPath, projectConfig.attributesDirectoryPath),
+            path.relative(rootDirectoryPath, projectConfig.segmentsDirectoryPath),
+            path.relative(rootDirectoryPath, projectConfig.targetsDirectoryPath),
+            path.relative(rootDirectoryPath, projectConfig.testsDirectoryPath),
+        ];
+}
+function createEmptyHistoryIndex() {
+    return {
+        entries: [],
+        bySet: {},
+        byEntity: {},
+        lastModifiedByEntity: {},
+    };
+}
+function addHistoryIndexEntry(target, key, entry) {
+    if (!target[key]) {
+        target[key] = [];
+    }
+    target[key].push(entry);
+}
+function buildCatalogHistoryIndex(entries) {
+    var index = createEmptyHistoryIndex();
+    index.entries = entries;
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var entry = entries_1[_i];
+        var seenSets = new Set();
+        for (var _a = 0, _b = entry.entities; _a < _b.length; _a++) {
+            var entity = _b[_a];
+            if (entity.type === "test") {
+                continue;
+            }
+            var entityKey = getHistoryEntityKey(entity.type, entity.key, entity.set);
+            addHistoryIndexEntry(index.byEntity, entityKey, entry);
+            if (!index.lastModifiedByEntity[entityKey]) {
+                index.lastModifiedByEntity[entityKey] = toLastModified(entry);
+            }
+            if (entity.set && !seenSets.has(entity.set)) {
+                seenSets.add(entity.set);
+                addHistoryIndexEntry(index.bySet, entity.set, entry);
+            }
+        }
+    }
+    return index;
+}
+function appendHistoryEntry(history, current) {
+    if (!current || current.entities.length === 0) {
+        return;
+    }
+    history.push({
+        commit: current.commit,
+        author: current.author,
+        timestamp: current.timestamp,
+        entities: current.entities,
+    });
+}
+function addHistoryEntity(current, entity) {
+    if (entity.type === "test") {
+        return;
+    }
+    var entityKey = getHistoryEntityKey(entity.type, entity.key, entity.set);
+    if (current.seenEntityKeys.has(entityKey)) {
+        return;
+    }
+    current.seenEntityKeys.add(entityKey);
+    current.entities.push(entity);
+}
+function streamCatalogGitHistory(rootDirectoryPath, projectConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pathPatterns, args;
+        return __generator(this, function (_a) {
+            pathPatterns = getCatalogHistoryPathPatterns(rootDirectoryPath, projectConfig);
+            args = __spreadArray([
+                "-C",
+                rootDirectoryPath,
+                "log",
+                "--name-only",
+                "--pretty=format:%x1e%h%x1f%an%x1f%aI",
+                "--relative",
+                "--no-merges",
+                "--"
+            ], pathPatterns, true);
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var current;
+                    var buffer = "";
+                    var history = [];
+                    var git = childProcess.spawn("git", args, {
+                        stdio: ["ignore", "pipe", "ignore"],
+                    });
+                    function processLine(line) {
+                        if (!line) {
+                            return;
+                        }
+                        if (line.startsWith("\x1e")) {
+                            appendHistoryEntry(history, current);
+                            var _a = line.slice(1).split("\x1f"), commit = _a[0], author = _a[1], timestamp = _a[2];
+                            current =
+                                commit && author && timestamp
+                                    ? {
+                                        commit: commit,
+                                        author: author,
+                                        timestamp: timestamp,
+                                        entities: [],
+                                        seenEntityKeys: new Set(),
+                                    }
+                                    : undefined;
+                            return;
+                        }
+                        if (!current) {
+                            return;
+                        }
+                        var entity = getEntityInfoFromRelativePath(rootDirectoryPath, projectConfig, line);
+                        if (entity) {
+                            addHistoryEntity(current, entity);
+                        }
+                    }
+                    git.stdout.setEncoding("utf8");
+                    git.stdout.on("data", function (chunk) {
+                        buffer += chunk;
+                        var lines = buffer.split(/\r?\n/);
+                        buffer = lines.pop() || "";
+                        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+                            var line = lines_1[_i];
+                            processLine(line);
+                        }
+                    });
+                    git.on("error", reject);
+                    git.on("close", function (code) {
+                        if (buffer) {
+                            processLine(buffer);
+                        }
+                        appendHistoryEntry(history, current);
+                        if (code === 0) {
+                            resolve(history);
+                            return;
+                        }
+                        reject(new Error("git log exited with code ".concat(code)));
+                    });
+                })];
+        });
+    });
+}
+function isExecutableFile(filePath) {
+    try {
+        var stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            return false;
+        }
+        if (process.platform === "win32") {
+            return true;
+        }
+        fs.accessSync(filePath, fs.constants.X_OK);
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+}
+function hasCommandInPath(command) {
+    var pathEntries = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+    var extensions = process.platform === "win32"
+        ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
+        : [""];
+    return pathEntries.some(function (entry) {
+        return extensions.some(function (extension) { return isExecutableFile(path.join(entry, "".concat(command).concat(extension))); });
+    });
+}
+function hasKnownEditorInstall(editor) {
+    if (hasCommandInPath(editor === "cursor" ? "cursor" : "code")) {
+        return true;
+    }
+    if (process.platform === "darwin") {
+        var appName = editor === "cursor" ? "Cursor.app" : "Visual Studio Code.app";
+        return [
+            path.join("/Applications", appName),
+            path.join(process.env.HOME || "", "Applications", appName),
+        ].some(function (appPath) { return fs.existsSync(appPath); });
+    }
+    if (process.platform === "win32") {
+        var localAppData = process.env.LOCALAPPDATA || "";
+        var programFiles = process.env.ProgramFiles || "";
+        var programFilesX86 = process.env["ProgramFiles(x86)"] || "";
+        var candidates = editor === "cursor"
+            ? [
+                path.join(localAppData, "Programs", "Cursor", "Cursor.exe"),
+                path.join(programFiles, "Cursor", "Cursor.exe"),
+                path.join(programFilesX86, "Cursor", "Cursor.exe"),
+            ]
+            : [
+                path.join(localAppData, "Programs", "Microsoft VS Code", "Code.exe"),
+                path.join(programFiles, "Microsoft VS Code", "Code.exe"),
+                path.join(programFilesX86, "Microsoft VS Code", "Code.exe"),
+            ];
+        return candidates.some(function (candidate) { return fs.existsSync(candidate); });
+    }
+    return false;
+}
+function detectDevEditors() {
+    var editors = [];
+    if (hasKnownEditorInstall("cursor")) {
+        editors.push({ id: "cursor", label: "Cursor", icon: "cursor" });
+    }
+    if (hasKnownEditorInstall("vscode")) {
+        editors.push({ id: "vscode", label: "VS Code", icon: "vscode" });
+    }
+    return editors;
+}
+function getGitHistoryIndex(rootDirectoryPath, projectConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _error_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    _a = buildCatalogHistoryIndex;
+                    return [4 /*yield*/, streamCatalogGitHistory(rootDirectoryPath, projectConfig)];
+                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                case 2:
+                    _error_1 = _b.sent();
+                    return [2 /*return*/, createEmptyHistoryIndex()];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getCurrentBranch(rootDirectoryPath) {
+    try {
+        return runGit(rootDirectoryPath, ["symbolic-ref", "--short", "HEAD"]).trim() || "HEAD";
+    }
+    catch (_error) {
+        return "HEAD";
+    }
+}
+function getRepositoryRootDirectoryPath(rootDirectoryPath) {
+    try {
+        return (getRealPath(runGit(rootDirectoryPath, ["rev-parse", "--show-toplevel"]).trim()) ||
+            getRealPath(rootDirectoryPath));
+    }
+    catch (_error) {
+        return getRealPath(rootDirectoryPath);
+    }
+}
+function getOwnerAndRepoFromGitRemote(origin, host) {
+    var escapedHost = host.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    var match = origin.match(new RegExp("".concat(escapedHost, "[:/]([^/]+)/(.+?)(?:\\.git)?$")));
+    if (!match) {
+        return undefined;
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+    };
+}
+function getRepoLinks(rootDirectoryPath) {
+    try {
+        var origin_1 = runGit(rootDirectoryPath, ["config", "--get", "remote.origin.url"]).trim();
+        var branch_1 = encodeURI(getCurrentBranch(rootDirectoryPath));
+        var providers = {
+            github: {
+                host: "github.com",
+                repository: function (owner, repo) { return "https://github.com/".concat(owner, "/").concat(repo); },
+                source: function (owner, repo) { return "https://github.com/".concat(owner, "/").concat(repo, "/blob/").concat(branch_1, "/{{path}}"); },
+                commit: function (owner, repo) { return "https://github.com/".concat(owner, "/").concat(repo, "/commit/{{hash}}"); },
+            },
+            gitlab: {
+                host: "gitlab.com",
+                repository: function (owner, repo) { return "https://gitlab.com/".concat(owner, "/").concat(repo); },
+                source: function (owner, repo) { return "https://gitlab.com/".concat(owner, "/").concat(repo, "/-/blob/").concat(branch_1, "/{{path}}"); },
+                commit: function (owner, repo) { return "https://gitlab.com/".concat(owner, "/").concat(repo, "/-/commit/{{hash}}"); },
+            },
+            bitbucket: {
+                host: "bitbucket.org",
+                repository: function (owner, repo) { return "https://bitbucket.org/".concat(owner, "/").concat(repo); },
+                source: function (owner, repo) { return "https://bitbucket.org/".concat(owner, "/").concat(repo, "/src/").concat(branch_1, "/{{path}}"); },
+                commit: function (owner, repo) { return "https://bitbucket.org/".concat(owner, "/").concat(repo, "/commits/{{hash}}"); },
+            },
+        };
+        for (var _i = 0, _a = Object.keys(providers); _i < _a.length; _i++) {
+            var provider = _a[_i];
+            var config = providers[provider];
+            var details = getOwnerAndRepoFromGitRemote(origin_1, config.host);
+            if (details) {
+                return {
+                    provider: provider,
+                    repository: config.repository(details.owner, details.repo),
+                    source: config.source(details.owner, details.repo),
+                    commit: config.commit(details.owner, details.repo),
+                };
+            }
+        }
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+function chunkHistory(history, pageSize) {
+    if (pageSize === void 0) { pageSize = exports.CATALOG_HISTORY_PAGE_SIZE; }
+    var pages = [];
+    for (var index = 0; index < history.length; index += pageSize) {
+        pages.push(history.slice(index, index + pageSize));
+    }
+    return pages.length > 0 ? pages : [[]];
+}
+function writeHistoryPages(directoryPath, history) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pages, index;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    pages = chunkHistory(history);
+                    index = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(index < pages.length)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, writeJson(path.join(directoryPath, "page-".concat(index + 1, ".json")), {
+                            page: index + 1,
+                            pageSize: exports.CATALOG_HISTORY_PAGE_SIZE,
+                            totalPages: pages.length,
+                            entries: pages[index],
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    index++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getHistoryForEntity(historyIndex, type, key, set) {
+    return historyIndex.byEntity[getHistoryEntityKey(type, key, set)] || [];
+}
+function getSourceFileInfo(repositoryRootDirectoryPath, rootDirectoryPath, projectConfig, type, key) {
+    var directoryByType = {
+        locale: projectConfig.localesDirectoryPath,
+        message: projectConfig.messagesDirectoryPath,
+        attribute: projectConfig.attributesDirectoryPath,
+        segment: projectConfig.segmentsDirectoryPath,
+        target: projectConfig.targetsDirectoryPath,
+    };
+    var extension = ".".concat(projectConfig.parser.extension);
+    var filePath = path.resolve(path.resolve.apply(path, __spreadArray([rootDirectoryPath,
+        directoryByType[type]], key.split(projectConfig.namespaceCharacter), false)) + extension);
+    var absolutePath = getRealPath(filePath);
+    return {
+        sourcePath: toPosixPath(path.relative(repositoryRootDirectoryPath, absolutePath)),
+        absolutePath: absolutePath,
+    };
+}
+function encodeEditorPath(filePath) {
+    return encodeURI(filePath.split(path.sep).join("/")).replace(/#/g, "%23").replace(/\?/g, "%3F");
+}
+function getEditorUri(editor, filePath) {
+    return "".concat(editor === "cursor" ? "cursor" : "vscode", "://file/").concat(encodeEditorPath(filePath));
+}
+function getEditorLinks(editors, sourceFileInfo) {
+    if (editors.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(editors.map(function (editor) { return [editor.id, getEditorUri(editor.id, sourceFileInfo.absolutePath)]; }));
+}
+function buildSetCatalog(context, set, projectConfig, datasource, outputRelativeDirectory) {
+    return __awaiter(this, void 0, void 0, function () {
+        function addToTranslationShard(msgKey, value) {
+            if (!value || value.length < 3)
+                return;
+            var lower = value.toLowerCase();
+            var seenSubs = new Set();
+            for (var i = 0; i <= lower.length - 3; i++) {
+                var sub = lower.slice(i, i + 3);
+                if (seenSubs.has(sub))
+                    continue;
+                seenSubs.add(sub);
+                var filename = Buffer.from(sub, "utf8").toString("hex");
+                if (!translationShards[filename])
+                    translationShards[filename] = {};
+                if (!translationShards[filename][msgKey])
+                    translationShards[filename][msgKey] = new Set();
+                translationShards[filename][msgKey].add(lower);
+            }
+        }
+        var outputDirectoryPath, _a, localeKeys, messageKeys, attributeKeys, segmentKeys, targetKeys, _b, locales, messages, attributes, segments, targets, messageTargets, targetMessages, localeTargets, attributeTargets, segmentTargets, attributesUsedInSegments, attributesUsedInMessages, segmentsUsedInMessages, _i, targetKeys_1, targetKey, targetLocaleKeys, _c, targetLocaleKeys_1, localeKey, _d, _e, messageKey, _f, segmentKeys_1, segmentKey, usedAttributes, _g, _h, attributeKey, _j, messageKeys_1, messageKey, message, targetsForMessage, _k, _l, override, usedAttributes, usedSegments, _m, _o, attributeKey, _p, targetsForMessage_1, targetKey, _q, _r, segmentKey, _s, targetsForMessage_2, targetKey, _t, _u, attributeKey, _v, _w, segmentKey, _x, _y, targetKey, history, localeDirections, duplicateResult, duplicatesByLocale, index, evaluatedMessageExamplesByKey, evaluatedLocaleExamplesByKey, _loop_1, _z, localeKeys_1, localeKey, translationShards, _loop_2, _0, messageKeys_2, messageKey, _1, _2, _3, prefix, messageMap, shardData, _4, _5, _6, msgKey, valueSet, _7, attributeKeys_1, attributeKey, attribute, sourceFileInfo, detail, _8, segmentKeys_2, segmentKey, segment, usedAttributes, sourceFileInfo, detail, _9, targetKeys_2, targetKey, target, targetLocaleKeys, formatsByLocale, formatRowsByLocale, _10, targetLocaleKeys_2, localeKey, sourceFileInfo, detail, _11, _12, type;
+        var _13, _14;
+        return __generator(this, function (_15) {
+            switch (_15.label) {
+                case 0:
+                    outputDirectoryPath = path.join(context.dataDirectoryPath, outputRelativeDirectory);
+                    return [4 /*yield*/, Promise.all([
+                            datasource.listLocales(),
+                            datasource.listMessages(),
+                            datasource.listAttributes(),
+                            datasource.listSegments(),
+                            datasource.listTargets(),
+                        ])];
+                case 1:
+                    _a = _15.sent(), localeKeys = _a[0], messageKeys = _a[1], attributeKeys = _a[2], segmentKeys = _a[3], targetKeys = _a[4];
+                    return [4 /*yield*/, Promise.all([
+                            readAll(localeKeys, function (key) { return datasource.readLocale(key); }),
+                            readAll(messageKeys, function (key) { return datasource.readMessage(key); }),
+                            readAll(attributeKeys, function (key) { return datasource.readAttribute(key); }),
+                            readAll(segmentKeys, function (key) { return datasource.readSegment(key); }),
+                            readAll(targetKeys, function (key) { return datasource.readTarget(key); }),
+                        ])];
+                case 2:
+                    _b = _15.sent(), locales = _b[0], messages = _b[1], attributes = _b[2], segments = _b[3], targets = _b[4];
+                    messageTargets = {};
+                    targetMessages = {};
+                    localeTargets = {};
+                    attributeTargets = {};
+                    segmentTargets = {};
+                    attributesUsedInSegments = {};
+                    attributesUsedInMessages = {};
+                    segmentsUsedInMessages = {};
+                    for (_i = 0, targetKeys_1 = targetKeys; _i < targetKeys_1.length; _i++) {
+                        targetKey = targetKeys_1[_i];
+                        targetMessages[targetKey] = getTargetMessageKeys(targets[targetKey], messageKeys);
+                        targetLocaleKeys = ((_13 = targets[targetKey].locales) === null || _13 === void 0 ? void 0 : _13.length)
+                            ? targets[targetKey].locales
+                            : localeKeys;
+                        for (_c = 0, targetLocaleKeys_1 = targetLocaleKeys; _c < targetLocaleKeys_1.length; _c++) {
+                            localeKey = targetLocaleKeys_1[_c];
+                            if (!localeTargets[localeKey]) {
+                                localeTargets[localeKey] = new Set();
+                            }
+                            localeTargets[localeKey].add(targetKey);
+                        }
+                        for (_d = 0, _e = targetMessages[targetKey]; _d < _e.length; _d++) {
+                            messageKey = _e[_d];
+                            if (!messageTargets[messageKey]) {
+                                messageTargets[messageKey] = [];
+                            }
+                            messageTargets[messageKey].push(targetKey);
+                        }
+                    }
+                    for (_f = 0, segmentKeys_1 = segmentKeys; _f < segmentKeys_1.length; _f++) {
+                        segmentKey = segmentKeys_1[_f];
+                        usedAttributes = new Set();
+                        collectAttributeKeysFromConditions(segments[segmentKey].conditions, usedAttributes);
+                        for (_g = 0, _h = Array.from(usedAttributes); _g < _h.length; _g++) {
+                            attributeKey = _h[_g];
+                            if (!attributesUsedInSegments[attributeKey]) {
+                                attributesUsedInSegments[attributeKey] = new Set();
+                            }
+                            attributesUsedInSegments[attributeKey].add(segmentKey);
+                        }
+                    }
+                    for (_j = 0, messageKeys_1 = messageKeys; _j < messageKeys_1.length; _j++) {
+                        messageKey = messageKeys_1[_j];
+                        message = messages[messageKey];
+                        targetsForMessage = messageTargets[messageKey] || [];
+                        for (_k = 0, _l = message.overrides || []; _k < _l.length; _k++) {
+                            override = _l[_k];
+                            usedAttributes = new Set();
+                            usedSegments = new Set();
+                            collectAttributeKeysFromConditions(override.conditions, usedAttributes);
+                            collectSegmentKeys(override.segments, usedSegments);
+                            for (_m = 0, _o = Array.from(usedAttributes); _m < _o.length; _m++) {
+                                attributeKey = _o[_m];
+                                if (!attributesUsedInMessages[attributeKey]) {
+                                    attributesUsedInMessages[attributeKey] = new Set();
+                                }
+                                attributesUsedInMessages[attributeKey].add(messageKey);
+                                for (_p = 0, targetsForMessage_1 = targetsForMessage; _p < targetsForMessage_1.length; _p++) {
+                                    targetKey = targetsForMessage_1[_p];
+                                    if (!attributeTargets[attributeKey]) {
+                                        attributeTargets[attributeKey] = new Set();
+                                    }
+                                    attributeTargets[attributeKey].add(targetKey);
+                                }
+                            }
+                            for (_q = 0, _r = Array.from(usedSegments); _q < _r.length; _q++) {
+                                segmentKey = _r[_q];
+                                if (!segmentsUsedInMessages[segmentKey]) {
+                                    segmentsUsedInMessages[segmentKey] = new Set();
+                                }
+                                segmentsUsedInMessages[segmentKey].add(messageKey);
+                                for (_s = 0, targetsForMessage_2 = targetsForMessage; _s < targetsForMessage_2.length; _s++) {
+                                    targetKey = targetsForMessage_2[_s];
+                                    if (!segmentTargets[segmentKey]) {
+                                        segmentTargets[segmentKey] = new Set();
+                                    }
+                                    segmentTargets[segmentKey].add(targetKey);
+                                }
+                            }
+                        }
+                    }
+                    for (_t = 0, _u = Object.keys(attributesUsedInSegments); _t < _u.length; _t++) {
+                        attributeKey = _u[_t];
+                        for (_v = 0, _w = Array.from(attributesUsedInSegments[attributeKey]); _v < _w.length; _v++) {
+                            segmentKey = _w[_v];
+                            for (_x = 0, _y = Array.from(segmentTargets[segmentKey] || []); _x < _y.length; _x++) {
+                                targetKey = _y[_x];
+                                if (!attributeTargets[attributeKey]) {
+                                    attributeTargets[attributeKey] = new Set();
+                                }
+                                attributeTargets[attributeKey].add(targetKey);
+                            }
+                        }
+                    }
+                    history = set ? context.historyIndex.bySet[set] || [] : context.historyIndex.entries;
+                    localeDirections = getLocaleDirections(locales);
+                    duplicateResult = context.duplicateResultsBySet[getDuplicateSetKey(set)] || {
+                        set: set || null,
+                        locales: [],
+                    };
+                    duplicatesByLocale = Object.fromEntries(duplicateResult.locales.map(function (entry) { return [entry.locale, entry]; }));
+                    index = {
+                        set: set,
+                        counts: {
+                            locale: localeKeys.length,
+                            message: messageKeys.length,
+                            attribute: attributeKeys.length,
+                            segment: segmentKeys.length,
+                            target: targetKeys.length,
+                        },
+                        entities: {
+                            locale: [],
+                            message: [],
+                            attribute: [],
+                            segment: [],
+                            target: [],
+                        },
+                    };
+                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history"), history)];
+                case 3:
+                    _15.sent();
+                    return [4 /*yield*/, context.runtime.resolveExamples(projectConfig, datasource, {
+                            onlyMessages: true,
+                        })];
+                case 4:
+                    evaluatedMessageExamplesByKey = (_15.sent()).messages.reduce(function (accumulator, example) {
+                        if (!accumulator[example.message]) {
+                            accumulator[example.message] = [];
+                        }
+                        accumulator[example.message].push(example);
+                        return accumulator;
+                    }, {});
+                    return [4 /*yield*/, context.runtime.resolveExamples(projectConfig, datasource, {
+                            onlyLocales: true,
+                        })];
+                case 5:
+                    evaluatedLocaleExamplesByKey = (_15.sent()).locales.reduce(function (accumulator, example) {
+                        var _a;
+                        var originalTranslation = example.message
+                            ? resolveTranslationRow((_a = messages[example.message]) === null || _a === void 0 ? void 0 : _a.translations, example.locale, locales)
+                                .value
+                            : undefined;
+                        if (!accumulator[example.locale]) {
+                            accumulator[example.locale] = [];
+                        }
+                        accumulator[example.locale].push(__assign(__assign({}, example), { originalTranslation: originalTranslation || undefined }));
+                        return accumulator;
+                    }, {});
+                    _loop_1 = function (localeKey) {
+                        var locale, sourceFileInfo, detail;
+                        return __generator(this, function (_16) {
+                            switch (_16.label) {
+                                case 0:
+                                    locale = locales[localeKey];
+                                    sourceFileInfo = getSourceFileInfo(context.repositoryRootDirectoryPath, context.rootDirectoryPath, projectConfig, "locale", localeKey);
+                                    detail = {
+                                        type: "locale",
+                                        key: localeKey,
+                                        entity: locale,
+                                        sourcePath: sourceFileInfo.sourcePath,
+                                        editLinks: getEditorLinks(context.devEditors, sourceFileInfo),
+                                        baseFormats: locale.formats || {},
+                                        computedFormats: context.runtime.resolveFormats(localeKey, locales),
+                                        formatRows: getFormatRows(context.runtime, localeKey, locales),
+                                        evaluatedExamples: evaluatedLocaleExamplesByKey[localeKey] || [],
+                                        targetFormats: Object.fromEntries(targetKeys.map(function (targetKey) { return [
+                                            targetKey,
+                                            context.runtime.resolveFormats(localeKey, locales, targets[targetKey]),
+                                        ]; })),
+                                        lastModified: getLastModified(context.historyIndex, "locale", localeKey, set || undefined),
+                                    };
+                                    index.entities.locale.push(getEntitySummary(locale, "locale", localeKey, context.historyIndex, set || undefined, {
+                                        targets: sortStrings(Array.from(localeTargets[localeKey] || [])),
+                                    }));
+                                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "entities", "locale", "".concat(encodeKey(localeKey), ".json")), detail)];
+                                case 1:
+                                    _16.sent();
+                                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "duplicates", "locales", "".concat(encodeKey(localeKey), ".json")), toLocaleDuplicatesFile(localeKey, duplicatesByLocale))];
+                                case 2:
+                                    _16.sent();
+                                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history", "locale", encodeKey(localeKey)), getHistoryForEntity(context.historyIndex, "locale", localeKey, set || undefined))];
+                                case 3:
+                                    _16.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _z = 0, localeKeys_1 = localeKeys;
+                    _15.label = 6;
+                case 6:
+                    if (!(_z < localeKeys_1.length)) return [3 /*break*/, 9];
+                    localeKey = localeKeys_1[_z];
+                    return [5 /*yield**/, _loop_1(localeKey)];
+                case 7:
+                    _15.sent();
+                    _15.label = 8;
+                case 8:
+                    _z++;
+                    return [3 /*break*/, 6];
+                case 9:
+                    translationShards = {};
+                    _loop_2 = function (messageKey) {
+                        var message, overrides, sourceFileInfo, detail, directLocales, overrideLocalesSet, _17, overrides_1, override, _18, _19, lk, overrideLocalesList, _20, localeKeys_2, localeKey, row, _21, overrides_2, override, overrideRow;
+                        return __generator(this, function (_22) {
+                            switch (_22.label) {
+                                case 0:
+                                    message = messages[messageKey];
+                                    overrides = (message.overrides || []).map(function (override) {
+                                        var attributes = new Set();
+                                        var overrideSegments = new Set();
+                                        collectAttributeKeysFromConditions(override.conditions, attributes);
+                                        collectSegmentKeys(override.segments, overrideSegments);
+                                        return __assign(__assign({}, override), { usedAttributes: sortStrings(Array.from(attributes)), usedSegments: sortStrings(Array.from(overrideSegments)) });
+                                    });
+                                    sourceFileInfo = getSourceFileInfo(context.repositoryRootDirectoryPath, context.rootDirectoryPath, projectConfig, "message", messageKey);
+                                    detail = {
+                                        type: "message",
+                                        key: messageKey,
+                                        entity: __assign(__assign({}, message), { overrides: overrides }),
+                                        sourcePath: sourceFileInfo.sourcePath,
+                                        editLinks: getEditorLinks(context.devEditors, sourceFileInfo),
+                                        targets: sortStrings(messageTargets[messageKey] || []),
+                                        localeKeys: localeKeys,
+                                        localeDirections: localeDirections,
+                                        translations: localeKeys.map(function (localeKey) {
+                                            return resolveTranslationRow(message.translations, localeKey, locales);
+                                        }),
+                                        evaluatedExamples: evaluatedMessageExamplesByKey[messageKey] || [],
+                                        overrideTranslations: overrides.map(function (override) { return ({
+                                            key: override.key,
+                                            rows: localeKeys.map(function (localeKey) {
+                                                return resolveTranslationRow(override.translations, localeKey, locales);
+                                            }),
+                                        }); }),
+                                        lastModified: getLastModified(context.historyIndex, "message", messageKey, set || undefined),
+                                    };
+                                    directLocales = localeKeys.filter(function (lk) { return message.translations && typeof message.translations[lk] === "string"; });
+                                    overrideLocalesSet = new Set();
+                                    for (_17 = 0, overrides_1 = overrides; _17 < overrides_1.length; _17++) {
+                                        override = overrides_1[_17];
+                                        for (_18 = 0, _19 = Object.keys(override.translations || {}); _18 < _19.length; _18++) {
+                                            lk = _19[_18];
+                                            overrideLocalesSet.add(lk);
+                                        }
+                                    }
+                                    overrideLocalesList = sortStrings(Array.from(overrideLocalesSet));
+                                    // Build translation shards (direct + inherited + override, all locales combined)
+                                    for (_20 = 0, localeKeys_2 = localeKeys; _20 < localeKeys_2.length; _20++) {
+                                        localeKey = localeKeys_2[_20];
+                                        row = resolveTranslationRow(message.translations, localeKey, locales);
+                                        if (row.source !== "missing" && row.value) {
+                                            addToTranslationShard(messageKey, row.value);
+                                        }
+                                        for (_21 = 0, overrides_2 = overrides; _21 < overrides_2.length; _21++) {
+                                            override = overrides_2[_21];
+                                            overrideRow = resolveTranslationRow(override.translations, localeKey, locales);
+                                            if (overrideRow.source !== "missing" && overrideRow.value) {
+                                                addToTranslationShard(messageKey, overrideRow.value);
+                                            }
+                                        }
+                                    }
+                                    index.entities.message.push(getEntitySummary(message, "message", messageKey, context.historyIndex, set || undefined, __assign(__assign({ targets: sortStrings(messageTargets[messageKey] || []) }, (directLocales.length > 0 ? { locales: sortStrings(directLocales) } : {})), (overrideLocalesList.length > 0 ? { overrideLocales: overrideLocalesList } : {}))));
+                                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "entities", "message", "".concat(encodeKey(messageKey), ".json")), detail)];
+                                case 1:
+                                    _22.sent();
+                                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history", "message", encodeKey(messageKey)), getHistoryForEntity(context.historyIndex, "message", messageKey, set || undefined))];
+                                case 2:
+                                    _22.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _0 = 0, messageKeys_2 = messageKeys;
+                    _15.label = 10;
+                case 10:
+                    if (!(_0 < messageKeys_2.length)) return [3 /*break*/, 13];
+                    messageKey = messageKeys_2[_0];
+                    return [5 /*yield**/, _loop_2(messageKey)];
+                case 11:
+                    _15.sent();
+                    _15.label = 12;
+                case 12:
+                    _0++;
+                    return [3 /*break*/, 10];
+                case 13:
+                    _1 = 0, _2 = Object.entries(translationShards);
+                    _15.label = 14;
+                case 14:
+                    if (!(_1 < _2.length)) return [3 /*break*/, 17];
+                    _3 = _2[_1], prefix = _3[0], messageMap = _3[1];
+                    shardData = {};
+                    for (_4 = 0, _5 = Object.entries(messageMap); _4 < _5.length; _4++) {
+                        _6 = _5[_4], msgKey = _6[0], valueSet = _6[1];
+                        shardData[msgKey] = Array.from(valueSet);
+                    }
+                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "translations", "".concat(prefix, ".json")), shardData)];
+                case 15:
+                    _15.sent();
+                    _15.label = 16;
+                case 16:
+                    _1++;
+                    return [3 /*break*/, 14];
+                case 17:
+                    _7 = 0, attributeKeys_1 = attributeKeys;
+                    _15.label = 18;
+                case 18:
+                    if (!(_7 < attributeKeys_1.length)) return [3 /*break*/, 22];
+                    attributeKey = attributeKeys_1[_7];
+                    attribute = attributes[attributeKey];
+                    sourceFileInfo = getSourceFileInfo(context.repositoryRootDirectoryPath, context.rootDirectoryPath, projectConfig, "attribute", attributeKey);
+                    detail = {
+                        type: "attribute",
+                        key: attributeKey,
+                        entity: attribute,
+                        sourcePath: sourceFileInfo.sourcePath,
+                        editLinks: getEditorLinks(context.devEditors, sourceFileInfo),
+                        usage: {
+                            segments: sortStrings(Array.from(attributesUsedInSegments[attributeKey] || [])),
+                            messages: sortStrings(Array.from(attributesUsedInMessages[attributeKey] || [])),
+                        },
+                        lastModified: getLastModified(context.historyIndex, "attribute", attributeKey, set || undefined),
+                    };
+                    index.entities.attribute.push(getEntitySummary(attribute, "attribute", attributeKey, context.historyIndex, set || undefined, {
+                        targets: sortStrings(Array.from(attributeTargets[attributeKey] || [])),
+                    }));
+                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "entities", "attribute", "".concat(encodeKey(attributeKey), ".json")), detail)];
+                case 19:
+                    _15.sent();
+                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history", "attribute", encodeKey(attributeKey)), getHistoryForEntity(context.historyIndex, "attribute", attributeKey, set || undefined))];
+                case 20:
+                    _15.sent();
+                    _15.label = 21;
+                case 21:
+                    _7++;
+                    return [3 /*break*/, 18];
+                case 22:
+                    _8 = 0, segmentKeys_2 = segmentKeys;
+                    _15.label = 23;
+                case 23:
+                    if (!(_8 < segmentKeys_2.length)) return [3 /*break*/, 27];
+                    segmentKey = segmentKeys_2[_8];
+                    segment = segments[segmentKey];
+                    usedAttributes = new Set();
+                    collectAttributeKeysFromConditions(segment.conditions, usedAttributes);
+                    sourceFileInfo = getSourceFileInfo(context.repositoryRootDirectoryPath, context.rootDirectoryPath, projectConfig, "segment", segmentKey);
+                    detail = {
+                        type: "segment",
+                        key: segmentKey,
+                        entity: segment,
+                        sourcePath: sourceFileInfo.sourcePath,
+                        editLinks: getEditorLinks(context.devEditors, sourceFileInfo),
+                        usage: {
+                            attributes: sortStrings(Array.from(usedAttributes)),
+                            messages: sortStrings(Array.from(segmentsUsedInMessages[segmentKey] || [])),
+                        },
+                        lastModified: getLastModified(context.historyIndex, "segment", segmentKey, set || undefined),
+                    };
+                    index.entities.segment.push(getEntitySummary(segment, "segment", segmentKey, context.historyIndex, set || undefined, {
+                        targets: sortStrings(Array.from(segmentTargets[segmentKey] || [])),
+                    }));
+                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "entities", "segment", "".concat(encodeKey(segmentKey), ".json")), detail)];
+                case 24:
+                    _15.sent();
+                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history", "segment", encodeKey(segmentKey)), getHistoryForEntity(context.historyIndex, "segment", segmentKey, set || undefined))];
+                case 25:
+                    _15.sent();
+                    _15.label = 26;
+                case 26:
+                    _8++;
+                    return [3 /*break*/, 23];
+                case 27:
+                    _9 = 0, targetKeys_2 = targetKeys;
+                    _15.label = 28;
+                case 28:
+                    if (!(_9 < targetKeys_2.length)) return [3 /*break*/, 32];
+                    targetKey = targetKeys_2[_9];
+                    target = targets[targetKey];
+                    targetLocaleKeys = ((_14 = target.locales) === null || _14 === void 0 ? void 0 : _14.length) ? target.locales : localeKeys;
+                    formatsByLocale = {};
+                    formatRowsByLocale = {};
+                    for (_10 = 0, targetLocaleKeys_2 = targetLocaleKeys; _10 < targetLocaleKeys_2.length; _10++) {
+                        localeKey = targetLocaleKeys_2[_10];
+                        formatsByLocale[localeKey] = context.runtime.resolveFormats(localeKey, locales, target);
+                        formatRowsByLocale[localeKey] = getFormatRows(context.runtime, localeKey, locales, target);
+                    }
+                    sourceFileInfo = getSourceFileInfo(context.repositoryRootDirectoryPath, context.rootDirectoryPath, projectConfig, "target", targetKey);
+                    detail = {
+                        type: "target",
+                        key: targetKey,
+                        entity: target,
+                        sourcePath: sourceFileInfo.sourcePath,
+                        editLinks: getEditorLinks(context.devEditors, sourceFileInfo),
+                        locales: targetLocaleKeys,
+                        formatsByLocale: formatsByLocale,
+                        formatRowsByLocale: formatRowsByLocale,
+                        messages: targetMessages[targetKey],
+                        lastModified: getLastModified(context.historyIndex, "target", targetKey, set || undefined),
+                    };
+                    index.entities.target.push(getEntitySummary(target, "target", targetKey, context.historyIndex, set || undefined, {
+                        messageCount: targetMessages[targetKey].length,
+                    }));
+                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "entities", "target", "".concat(encodeKey(targetKey), ".json")), detail)];
+                case 29:
+                    _15.sent();
+                    return [4 /*yield*/, writeHistoryPages(path.join(outputDirectoryPath, "history", "target", encodeKey(targetKey)), getHistoryForEntity(context.historyIndex, "target", targetKey, set || undefined))];
+                case 30:
+                    _15.sent();
+                    _15.label = 31;
+                case 31:
+                    _9++;
+                    return [3 /*break*/, 28];
+                case 32:
+                    for (_11 = 0, _12 = Object.keys(index.entities); _11 < _12.length; _11++) {
+                        type = _12[_11];
+                        index.entities[type].sort(function (a, b) { return a.key.localeCompare(b.key); });
+                    }
+                    return [4 /*yield*/, writeJson(path.join(outputDirectoryPath, "index.json"), index)];
+                case 33:
+                    _15.sent();
+                    return [2 /*return*/, index];
+            }
+        });
+    });
+}
+function copyCatalogAssets(outputDirectoryPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var packageJsonPath, distPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    try {
+                        packageJsonPath = require.resolve("@messagevisor/catalog/package.json");
+                    }
+                    catch (_error) {
+                        throw new Error("Unable to resolve @messagevisor/catalog. Run npm install from the repository root.");
+                    }
+                    distPath = path.join(path.dirname(packageJsonPath), "dist");
+                    if (!fs.existsSync(distPath)) {
+                        throw new Error("Catalog UI bundle not found. Run `npm run build --workspace @messagevisor/catalog` first.");
+                    }
+                    return [4 /*yield*/, fs.promises.cp(distPath, outputDirectoryPath, { recursive: true })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function exportCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasource_1) {
+    return __awaiter(this, arguments, void 0, function (runtime, rootDirectoryPath, projectConfig, datasource, options) {
+        var outputDirectoryPath, dataDirectoryPath, devEditors, historyIndex, duplicateTranslations, duplicateResultsBySet, context, executions, setIndexes, _i, executions_1, execution, outputRelativeDirectory, _a, _b, manifest;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    outputDirectoryPath = options.outDir
+                        ? path.resolve(rootDirectoryPath, options.outDir)
+                        : projectConfig.catalogDirectoryPath;
+                    dataDirectoryPath = path.join(outputDirectoryPath, "data");
+                    return [4 /*yield*/, fs.promises.rm(outputDirectoryPath, { recursive: true, force: true })];
+                case 1:
+                    _c.sent();
+                    return [4 /*yield*/, fs.promises.mkdir(dataDirectoryPath, { recursive: true })];
+                case 2:
+                    _c.sent();
+                    if (!(options.copyAssets !== false)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, copyCatalogAssets(outputDirectoryPath)];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4:
+                    devEditors = options.dev ? options.devEditors || detectDevEditors() : [];
+                    return [4 /*yield*/, getGitHistoryIndex(rootDirectoryPath, projectConfig)];
+                case 5:
+                    historyIndex = _c.sent();
+                    return [4 /*yield*/, runtime.findDuplicateTranslations(projectConfig, datasource)];
+                case 6:
+                    duplicateTranslations = _c.sent();
+                    duplicateResultsBySet = Object.fromEntries(duplicateTranslations.results.map(function (result) { return [getDuplicateSetKey(result.set), result]; }));
+                    context = {
+                        rootDirectoryPath: rootDirectoryPath,
+                        repositoryRootDirectoryPath: getRepositoryRootDirectoryPath(rootDirectoryPath),
+                        outputDirectoryPath: outputDirectoryPath,
+                        dataDirectoryPath: dataDirectoryPath,
+                        historyIndex: historyIndex,
+                        runtime: runtime,
+                        devEditors: devEditors,
+                        duplicateResultsBySet: duplicateResultsBySet,
+                    };
+                    return [4 /*yield*/, runtime.getProjectSetExecutions(projectConfig, datasource)];
+                case 7:
+                    executions = _c.sent();
+                    setIndexes = {};
+                    return [4 /*yield*/, writeHistoryPages(path.join(dataDirectoryPath, "project", "history"), historyIndex.entries)];
+                case 8:
+                    _c.sent();
+                    _i = 0, executions_1 = executions;
+                    _c.label = 9;
+                case 9:
+                    if (!(_i < executions_1.length)) return [3 /*break*/, 12];
+                    execution = executions_1[_i];
+                    outputRelativeDirectory = projectConfig.sets ? path.join("sets", execution.set) : "root";
+                    _a = setIndexes;
+                    _b = execution.set || "root";
+                    return [4 /*yield*/, buildSetCatalog(context, execution.set, execution.projectConfig, execution.datasource, outputRelativeDirectory)];
+                case 10:
+                    _a[_b] = _c.sent();
+                    _c.label = 11;
+                case 11:
+                    _i++;
+                    return [3 /*break*/, 9];
+                case 12:
+                    manifest = {
+                        schemaVersion: exports.CATALOG_SCHEMA_VERSION,
+                        generatedAt: new Date().toISOString(),
+                        router: options.browserRouter === false ? "hash" : "browser",
+                        sets: projectConfig.sets,
+                        setKeys: projectConfig.sets ? executions.map(function (execution) { return execution.set; }) : [],
+                        dev: options.dev ? { editors: devEditors } : undefined,
+                        links: getRepoLinks(rootDirectoryPath),
+                        paths: {
+                            projectHistory: "data/project/history/page-1.json",
+                            root: projectConfig.sets ? undefined : "data/root/index.json",
+                            sets: projectConfig.sets
+                                ? Object.fromEntries(executions.map(function (execution) { return [
+                                    execution.set,
+                                    "data/sets/".concat(encodeURIComponent(execution.set), "/index.json"),
+                                ]; }))
+                                : undefined,
+                        },
+                        counts: Object.fromEntries(Object.keys(setIndexes).map(function (key) { return [key, setIndexes[key].counts]; })),
+                    };
+                    return [4 /*yield*/, writeJson(path.join(dataDirectoryPath, "manifest.json"), manifest)];
+                case 13:
+                    _c.sent();
+                    console.log("Catalog exported to ".concat(outputDirectoryPath));
+                    return [2 /*return*/, {
+                            outputDirectoryPath: outputDirectoryPath,
+                            manifest: manifest,
+                        }];
+            }
+        });
+    });
+}
+function getContentType(filePath) {
+    var extension = path.extname(filePath);
+    switch (extension) {
+        case ".js":
+            return "text/javascript";
+        case ".css":
+            return "text/css";
+        case ".json":
+            return "application/json";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".ico":
+            return "image/x-icon";
+        default:
+            return "text/html";
+    }
+}
+function getCatalogLiveReloadClientScript() {
+    return [
+        "<script>",
+        "(() => {",
+        '  const source = new EventSource("/__messagevisor_catalog_reload");',
+        '  source.addEventListener("reload", () => window.location.reload());',
+        "  source.onerror = () => {",
+        "    source.close();",
+        "    setTimeout(() => window.location.reload(), 1000);",
+        "  };",
+        "})();",
+        "</script>",
+    ].join("");
+}
+function injectCatalogLiveReloadClient(html) {
+    var script = getCatalogLiveReloadClientScript();
+    if (html.includes("</body>")) {
+        return html.replace("</body>", "".concat(script, "</body>"));
+    }
+    return "".concat(html).concat(script);
+}
+function createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, onChange) {
+    function shouldIgnore(targetPath) {
+        var resolvedTargetPath = path.resolve(targetPath);
+        return ignoredDirectoryPaths.some(function (ignoredDirectoryPath) {
+            var resolvedIgnoredPath = path.resolve(ignoredDirectoryPath);
+            return (resolvedTargetPath === resolvedIgnoredPath ||
+                resolvedTargetPath.startsWith("".concat(resolvedIgnoredPath).concat(path.sep)));
+        });
+    }
+    function collectSnapshotEntries(directoryPath, snapshotEntries) {
+        if (shouldIgnore(directoryPath)) {
+            return;
+        }
+        var entries = [];
+        try {
+            entries = fs.readdirSync(directoryPath, { withFileTypes: true });
+        }
+        catch (_a) {
+            return;
+        }
+        for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+            var entry = entries_2[_i];
+            var entryPath = path.join(directoryPath, entry.name);
+            if (shouldIgnore(entryPath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                collectSnapshotEntries(entryPath, snapshotEntries);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            try {
+                var stat = fs.statSync(entryPath);
+                var relativePath = path.relative(rootDirectoryPath, entryPath);
+                snapshotEntries.push("".concat(relativePath, ":").concat(stat.size, ":").concat(stat.mtimeMs));
+            }
+            catch (_b) {
+                // Ignore transient editor save races.
+            }
+        }
+    }
+    function createSnapshot() {
+        var snapshotEntries = [];
+        collectSnapshotEntries(rootDirectoryPath, snapshotEntries);
+        snapshotEntries.sort();
+        return snapshotEntries.join("|");
+    }
+    var previousSnapshot = createSnapshot();
+    var interval = setInterval(function () {
+        var nextSnapshot = createSnapshot();
+        if (nextSnapshot === previousSnapshot) {
+            return;
+        }
+        previousSnapshot = nextSnapshot;
+        onChange(rootDirectoryPath);
+    }, 250);
+    return function () {
+        clearInterval(interval);
+    };
+}
+function serveCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasource_1) {
+    return __awaiter(this, arguments, void 0, function (runtime, rootDirectoryPath, projectConfig, datasource, options) {
+        function triggerReload() {
+            liveReloadClients.forEach(function (client) {
+                client.write("event: reload\n");
+                client.write("data: reload\n\n");
+            });
+        }
+        var outputDirectoryPath, port, liveReloadClients, server;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    outputDirectoryPath = options.outDir
+                        ? path.resolve(rootDirectoryPath, options.outDir)
+                        : projectConfig.catalogDirectoryPath;
+                    if (!!fs.existsSync(outputDirectoryPath)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, exportCatalog(runtime, rootDirectoryPath, projectConfig, datasource, {
+                            outDir: outputDirectoryPath,
+                            browserRouter: options.browserRouter,
+                        })];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    port = Number(options.port || 3000);
+                    liveReloadClients = new Set();
+                    server = http.createServer(function (request, response) {
+                        var requestedUrl = decodeURIComponent((request.url || "/").split("?")[0]);
+                        if (options.liveReload && requestedUrl === "/__messagevisor_catalog_reload") {
+                            response.writeHead(200, {
+                                "Content-Type": "text/event-stream",
+                                "Cache-Control": "no-cache, no-transform",
+                                Connection: "keep-alive",
+                            });
+                            response.write("\n");
+                            liveReloadClients.add(response);
+                            request.on("close", function () {
+                                liveReloadClients.delete(response);
+                            });
+                            return;
+                        }
+                        var requestedPath = requestedUrl === "/" ? "/index.html" : requestedUrl;
+                        var filePath = path.join(outputDirectoryPath, requestedPath);
+                        var safeFilePath = filePath.startsWith(outputDirectoryPath)
+                            ? filePath
+                            : path.join(outputDirectoryPath, "index.html");
+                        fs.readFile(safeFilePath, function (error, content) {
+                            if (!error) {
+                                if (options.liveReload && path.basename(safeFilePath) === "index.html") {
+                                    var html = injectCatalogLiveReloadClient(content.toString("utf8"));
+                                    response.writeHead(200, { "Content-Type": "text/html" });
+                                    response.end(html);
+                                    return;
+                                }
+                                response.writeHead(200, { "Content-Type": getContentType(safeFilePath) });
+                                response.end(content);
+                                return;
+                            }
+                            if (requestedPath.startsWith("/assets/") ||
+                                requestedPath.startsWith("/data/") ||
+                                requestedPath === "/favicon.ico") {
+                                response.writeHead(404, { "Content-Type": "text/plain" });
+                                response.end("404 Not Found");
+                                return;
+                            }
+                            fs.readFile(path.join(outputDirectoryPath, "index.html"), function (indexError, indexContent) {
+                                if (indexError) {
+                                    response.writeHead(500, { "Content-Type": "text/plain" });
+                                    response.end("Catalog index.html not found.");
+                                    return;
+                                }
+                                if (options.liveReload) {
+                                    response.writeHead(200, { "Content-Type": "text/html" });
+                                    response.end(injectCatalogLiveReloadClient(indexContent.toString("utf8")));
+                                    return;
+                                }
+                                response.writeHead(200, { "Content-Type": "text/html" });
+                                response.end(indexContent);
+                            });
+                        });
+                    });
+                    server.on("error", function (error) {
+                        console.error("Unable to serve catalog on http://127.0.0.1:".concat(port, "/"));
+                        console.error(error);
+                        process.exitCode = 1;
+                    });
+                    server.listen(port, "127.0.0.1", function () {
+                        console.log("Catalog running at http://127.0.0.1:".concat(port, "/"));
+                    });
+                    return [2 /*return*/, {
+                            close: function () {
+                                return new Promise(function (resolve, reject) {
+                                    server.close(function (error) {
+                                        if (error) {
+                                            reject(error);
+                                            return;
+                                        }
+                                        resolve();
+                                    });
+                                });
+                            },
+                            triggerReload: triggerReload,
+                        }];
+            }
+        });
+    });
+}
+function createCatalogApi(runtime) {
+    return {
+        exportCatalog: function (rootDirectoryPath, projectConfig, datasource, options) {
+            if (options === void 0) { options = {}; }
+            return exportCatalog(runtime, rootDirectoryPath, projectConfig, datasource, options);
+        },
+        serveCatalog: function (rootDirectoryPath, projectConfig, datasource, options) {
+            if (options === void 0) { options = {}; }
+            return serveCatalog(runtime, rootDirectoryPath, projectConfig, datasource, options);
+        },
+    };
+}
+function createCatalogPlugin(runtime, api) {
+    var _this = this;
+    if (api === void 0) { api = createCatalogApi(runtime); }
+    return {
+        command: "catalog [subcommand]",
+        handler: function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var allowedSubcommands, browserRouter, server_1, outputDirectoryPath, ignoredDirectoryPaths, exportInFlight_1, exportQueued_1, queuedReason_1, debounceTimer_1, runExportAndReload_1, stopWatchingProject;
+            var _this = this;
+            var rootDirectoryPath = _b.rootDirectoryPath, projectConfig = _b.projectConfig, datasource = _b.datasource, parsed = _b.parsed;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        allowedSubcommands = ["export", "serve"];
+                        browserRouter = !(parsed.hashRouter || parsed["hash-router"]);
+                        if (!!parsed.subcommand) return [3 /*break*/, 3];
+                        return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
+                                outDir: parsed.outDir,
+                                copyAssets: !parsed.noAssets,
+                                browserRouter: browserRouter,
+                                dev: true,
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, api.serveCatalog(rootDirectoryPath, projectConfig, datasource, {
+                                outDir: parsed.outDir,
+                                port: parsed.port || parsed.p,
+                                browserRouter: browserRouter,
+                                liveReload: true,
+                            })];
+                    case 2:
+                        server_1 = _c.sent();
+                        outputDirectoryPath = parsed.outDir
+                            ? path.resolve(rootDirectoryPath, parsed.outDir)
+                            : projectConfig.catalogDirectoryPath;
+                        ignoredDirectoryPaths = [
+                            path.join(rootDirectoryPath, ".git"),
+                            path.join(rootDirectoryPath, "node_modules"),
+                            path.join(rootDirectoryPath, ".messagevisor"),
+                            path.join(rootDirectoryPath, "datafiles"),
+                            path.join(rootDirectoryPath, "catalog"),
+                            path.join(rootDirectoryPath, "exports"),
+                            path.join(rootDirectoryPath, "imports"),
+                            outputDirectoryPath,
+                        ];
+                        exportInFlight_1 = false;
+                        exportQueued_1 = false;
+                        queuedReason_1 = null;
+                        debounceTimer_1 = null;
+                        runExportAndReload_1 = function (reason) { return __awaiter(_this, void 0, void 0, function () {
+                            var error_1, nextReason;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (exportInFlight_1) {
+                                            exportQueued_1 = true;
+                                            queuedReason_1 = queuedReason_1 || reason;
+                                            return [2 /*return*/];
+                                        }
+                                        exportInFlight_1 = true;
+                                        console.log("\n[catalog] Re-exporting because ".concat(reason));
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, 4, 5]);
+                                        return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
+                                                outDir: parsed.outDir,
+                                                copyAssets: !parsed.noAssets,
+                                                browserRouter: browserRouter,
+                                                dev: true,
+                                            })];
+                                    case 2:
+                                        _a.sent();
+                                        server_1.triggerReload();
+                                        return [3 /*break*/, 5];
+                                    case 3:
+                                        error_1 = _a.sent();
+                                        console.error("[catalog] Export failed during watch mode");
+                                        console.error(error_1);
+                                        return [3 /*break*/, 5];
+                                    case 4:
+                                        exportInFlight_1 = false;
+                                        if (exportQueued_1) {
+                                            nextReason = queuedReason_1 || "more project changes";
+                                            exportQueued_1 = false;
+                                            queuedReason_1 = null;
+                                            void runExportAndReload_1(nextReason);
+                                        }
+                                        return [7 /*endfinally*/];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        stopWatchingProject = createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, function (changedPath) {
+                            var reason = "project change in ".concat(path.relative(rootDirectoryPath, changedPath) || ".");
+                            if (debounceTimer_1) {
+                                clearTimeout(debounceTimer_1);
+                            }
+                            debounceTimer_1 = setTimeout(function () {
+                                debounceTimer_1 = null;
+                                void runExportAndReload_1(reason);
+                            }, 150);
+                        });
+                        process.on("exit", stopWatchingProject);
+                        return [2 /*return*/];
+                    case 3:
+                        if (allowedSubcommands.indexOf(parsed.subcommand) === -1) {
+                            console.log("Please specify a subcommand: `export` or `serve`");
+                            return [2 /*return*/, false];
+                        }
+                        if (!(parsed.subcommand === "export")) return [3 /*break*/, 5];
+                        return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
+                                outDir: parsed.outDir,
+                                copyAssets: !parsed.noAssets,
+                                browserRouter: browserRouter,
+                            })];
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        if (!(parsed.subcommand === "serve")) return [3 /*break*/, 7];
+                        return [4 /*yield*/, api.serveCatalog(rootDirectoryPath, projectConfig, datasource, {
+                                outDir: parsed.outDir,
+                                port: parsed.port || parsed.p,
+                                browserRouter: browserRouter,
+                            })];
+                    case 6:
+                        _c.sent();
+                        _c.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); },
+        examples: [
+            {
+                command: "catalog",
+                description: "generate and serve the static catalog locally",
+            },
+            {
+                command: "catalog export",
+                description: "generate static catalog with project data",
+            },
+            {
+                command: "catalog serve",
+                description: "serve the generated catalog locally",
+            },
+        ],
+    };
+}
+//# sourceMappingURL=index.js.map