@messagevisor/catalog 0.7.0 → 0.8.0

package/lib/node/index.js

@@ -89,7 +89,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     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.__catalogDevInternals = exports.CATALOG_HISTORY_PAGE_SIZE = exports.CATALOG_SCHEMA_VERSION = void 0;
 exports.exportCatalog = exportCatalog;
 exports.serveCatalog = serveCatalog;
 exports.createCatalogApi = createCatalogApi;
@@ -1503,12 +1503,404 @@ function copyCatalogAssets(outputDirectoryPath) {
         });
     });
 }
+function createCatalogDevSession(rootDirectoryPath_1, projectConfig_1) {
+    return __awaiter(this, arguments, void 0, function (rootDirectoryPath, projectConfig, options) {
+        var outputDirectoryPath;
+        var _a;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    outputDirectoryPath = options.outDir
+                        ? path.resolve(rootDirectoryPath, options.outDir)
+                        : projectConfig.catalogDirectoryPath;
+                    _a = {
+                        outputDirectoryPath: outputDirectoryPath,
+                        devEditors: options.devEditors || detectDevEditors()
+                    };
+                    return [4 /*yield*/, getGitHistoryIndex(rootDirectoryPath, projectConfig)];
+                case 1: return [2 /*return*/, (_a.historyIndex = _b.sent(),
+                        _a.links = getRepoLinks(rootDirectoryPath),
+                        _a.repositoryRootDirectoryPath = getRepositoryRootDirectoryPath(rootDirectoryPath),
+                        _a.repositorySourceRootDirectoryPath = getRepositorySourceRootDirectoryPath(rootDirectoryPath),
+                        _a)];
+            }
+        });
+    });
+}
+function readJsonFile(filePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, _error_2;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, fs.promises.readFile(filePath, "utf8")];
+                case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+                case 2:
+                    _error_2 = _c.sent();
+                    return [2 /*return*/, undefined];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getOutputRelativeDirectory(projectConfig, set) {
+    return projectConfig.sets ? path.join("sets", set || "") : "root";
+}
+function getDataOutputDirectoryPath(session, projectConfig, set) {
+    return path.join(session.outputDirectoryPath, "data", getOutputRelativeDirectory(projectConfig, set));
+}
+function getEntityKeyFromChangedPath(rootDirectoryPath, projectConfig, changedPath) {
+    var relativePath = path.relative(rootDirectoryPath, changedPath);
+    if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    return getEntityInfoFromRelativePath(rootDirectoryPath, projectConfig, relativePath);
+}
+function getChangedPathSummary(rootDirectoryPath, changedPaths) {
+    return changedPaths
+        .slice(0, 3)
+        .map(function (changedPath) { return formatCatalogPath(rootDirectoryPath, changedPath); })
+        .join(", ");
+}
+function classifyCatalogDevChanges(rootDirectoryPath, projectConfig, changedPaths, options) {
+    var reason = getChangedPathSummary(rootDirectoryPath, changedPaths) || "project changes";
+    var infos = changedPaths.map(function (changedPath) {
+        return getEntityKeyFromChangedPath(rootDirectoryPath, projectConfig, changedPath);
+    });
+    if (infos.length === 0 || infos.some(function (info) { return !info; })) {
+        return { kind: "full", reason: reason };
+    }
+    var sets = new Set(infos.map(function (info) { return (info === null || info === void 0 ? void 0 : info.set) || ""; }));
+    var types = new Set(infos.map(function (info) { return info === null || info === void 0 ? void 0 : info.type; }));
+    if (sets.size > 1) {
+        return { kind: "full", reason: reason };
+    }
+    var set = Array.from(sets)[0] || undefined;
+    if (types.size === 1 &&
+        types.has("message") &&
+        !options.withTranslationSearch &&
+        !options.withDuplicates) {
+        return {
+            kind: "message",
+            reason: reason,
+            set: set,
+            messageKeys: sortStrings(infos.map(function (info) { return (info === null || info === void 0 ? void 0 : info.key) || ""; }).filter(Boolean)),
+        };
+    }
+    if (projectConfig.sets &&
+        set &&
+        types.size > 0 &&
+        !types.has("test") &&
+        !options.withTranslationSearch &&
+        !options.withDuplicates) {
+        return { kind: "set", reason: reason, set: set };
+    }
+    return { kind: "full", reason: reason };
+}
+function writeCatalogManifest(writer, rootDirectoryPath, projectConfig, session, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var manifest;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    manifest = {
+                        schemaVersion: exports.CATALOG_SCHEMA_VERSION,
+                        generatedAt: new Date().toISOString(),
+                        router: options.browserRouter === false ? "hash" : "browser",
+                        sets: projectConfig.sets,
+                        setKeys: projectConfig.sets ? options.executions.map(function (execution) { return execution.set; }) : [],
+                        dev: { editors: session.devEditors },
+                        features: {
+                            translationSearch: options.withTranslationSearch,
+                            duplicates: options.withDuplicates,
+                        },
+                        links: session.links,
+                        paths: {
+                            projectHistory: "data/project/history/page-1.json",
+                            root: projectConfig.sets ? undefined : "data/root/index.json",
+                            sets: projectConfig.sets
+                                ? Object.fromEntries(options.executions.map(function (execution) { return [
+                                    execution.set,
+                                    "data/sets/".concat(encodeURIComponent(execution.set), "/index.json"),
+                                ]; }))
+                                : undefined,
+                        },
+                        counts: Object.fromEntries(Object.keys(options.setIndexes).map(function (key) { return [key, options.setIndexes[key].counts]; })),
+                    };
+                    return [4 /*yield*/, writer.write(path.join(session.outputDirectoryPath, "data", "manifest.json"), manifest)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, manifest];
+            }
+        });
+    });
+}
+function getMessageRelationshipFingerprint(message) {
+    var attributes = new Set();
+    var segments = new Set();
+    for (var _i = 0, _a = message.overrides || []; _i < _a.length; _i++) {
+        var override = _a[_i];
+        collectAttributeKeysFromConditions(override.conditions, attributes);
+        collectSegmentKeys(override.segments, segments);
+    }
+    return {
+        attributes: sortStrings(Array.from(attributes)),
+        segments: sortStrings(Array.from(segments)),
+    };
+}
+function sameStringList(left, right) {
+    if (left === void 0) { left = []; }
+    if (right === void 0) { right = []; }
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every(function (value, index) { return value === right[index]; });
+}
+function summarizeMessage(message, messageKey, historyIndex, set, targets) {
+    var directLocales = Object.keys(message.translations || {});
+    var overrideLocalesSet = new Set();
+    for (var _i = 0, _a = message.overrides || []; _i < _a.length; _i++) {
+        var override = _a[_i];
+        for (var _b = 0, _c = Object.keys(override.translations || {}); _b < _c.length; _b++) {
+            var localeKey = _c[_b];
+            overrideLocalesSet.add(localeKey);
+        }
+    }
+    var overrideLocales = sortStrings(Array.from(overrideLocalesSet));
+    return getEntitySummary(message, "message", messageKey, historyIndex, set, __assign(__assign({ targets: targets }, (directLocales.length > 0 ? { locales: sortStrings(directLocales) } : {})), (overrideLocales.length > 0 ? { overrideLocales: overrideLocales } : {})));
+}
+function tryRebuildCatalogMessage(runtime, rootDirectoryPath, rootProjectConfig, projectConfig, datasource, session, request) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dataDirectoryPath, indexPath, index, _a, localeKeys, messageKeys, targetKeys, messageKeySet, _b, locales, targets, localeDirections, targetMessages, writer, _loop_1, _i, _c, messageKey, state_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (request.kind !== "message" || !request.messageKeys || request.messageKeys.length === 0) {
+                        return [2 /*return*/, false];
+                    }
+                    dataDirectoryPath = getDataOutputDirectoryPath(session, rootProjectConfig, request.set);
+                    indexPath = path.join(dataDirectoryPath, "index.json");
+                    return [4 /*yield*/, readJsonFile(indexPath)];
+                case 1:
+                    index = _d.sent();
+                    if (!index) {
+                        return [2 /*return*/, false];
+                    }
+                    return [4 /*yield*/, Promise.all([
+                            datasource.listLocales(),
+                            datasource.listMessages(),
+                            datasource.listTargets(),
+                        ])];
+                case 2:
+                    _a = (_d.sent()), localeKeys = _a[0], messageKeys = _a[1], targetKeys = _a[2];
+                    messageKeySet = new Set(messageKeys);
+                    if (request.messageKeys.some(function (messageKey) { return !messageKeySet.has(messageKey); })) {
+                        return [2 /*return*/, false];
+                    }
+                    return [4 /*yield*/, Promise.all([
+                            readAll(localeKeys, function (key) { return datasource.readLocale(key); }),
+                            readAll(targetKeys, function (key) { return datasource.readTarget(key); }),
+                        ])];
+                case 3:
+                    _b = _d.sent(), locales = _b[0], targets = _b[1];
+                    localeDirections = getLocaleDirections(locales);
+                    targetMessages = Object.fromEntries(targetKeys.map(function (targetKey) { return [
+                        targetKey,
+                        getTargetMessageKeys(targets[targetKey], messageKeys),
+                    ]; }));
+                    writer = new CatalogJsonWriter();
+                    _loop_1 = function (messageKey) {
+                        var oldDetailPath, oldDetail, message, messageTargets, oldRelationshipFingerprint, nextRelationshipFingerprint, examples, overrides, sourceFileInfo, detail, nextSummary, existingSummaryIndex;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0:
+                                    oldDetailPath = path.join(dataDirectoryPath, "entities", "message", "".concat(encodeKey(messageKey), ".json"));
+                                    return [4 /*yield*/, readJsonFile(oldDetailPath)];
+                                case 1:
+                                    oldDetail = _e.sent();
+                                    if (!oldDetail) {
+                                        return [2 /*return*/, { value: false }];
+                                    }
+                                    return [4 /*yield*/, datasource.readMessage(messageKey)];
+                                case 2:
+                                    message = _e.sent();
+                                    messageTargets = sortStrings(targetKeys.filter(function (targetKey) { return targetMessages[targetKey].includes(messageKey); }));
+                                    if (!sameStringList(sortStrings(oldDetail.targets || []), messageTargets)) {
+                                        return [2 /*return*/, { value: false }];
+                                    }
+                                    oldRelationshipFingerprint = getMessageRelationshipFingerprint(oldDetail.entity || {});
+                                    nextRelationshipFingerprint = getMessageRelationshipFingerprint(message);
+                                    if (!sameStringList(oldRelationshipFingerprint.attributes, nextRelationshipFingerprint.attributes) ||
+                                        !sameStringList(oldRelationshipFingerprint.segments, nextRelationshipFingerprint.segments)) {
+                                        return [2 /*return*/, { value: false }];
+                                    }
+                                    return [4 /*yield*/, runtime.resolveExamples(projectConfig, datasource, {
+                                            set: request.set,
+                                            message: messageKey,
+                                            onlyMessages: true,
+                                        })];
+                                case 3:
+                                    examples = _e.sent();
+                                    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(session.repositorySourceRootDirectoryPath, rootDirectoryPath, projectConfig, "message", messageKey, { resolveAbsolutePath: session.devEditors.length > 0 });
+                                    detail = {
+                                        type: "message",
+                                        key: messageKey,
+                                        entity: __assign(__assign({}, message), { overrides: overrides }),
+                                        sourcePath: sourceFileInfo.sourcePath,
+                                        editLinks: getEditorLinks(session.devEditors, sourceFileInfo),
+                                        targets: messageTargets,
+                                        localeKeys: localeKeys,
+                                        localeDirections: localeDirections,
+                                        translations: localeKeys.map(function (localeKey) {
+                                            return resolveTranslationRow(message.translations, localeKey, locales);
+                                        }),
+                                        evaluatedExamples: examples.messages,
+                                        overrideTranslations: overrides.map(function (override) { return ({
+                                            key: override.key,
+                                            rows: localeKeys.map(function (localeKey) {
+                                                return resolveTranslationRow(override.translations, localeKey, locales);
+                                            }),
+                                        }); }),
+                                        lastModified: getLastModified(session.historyIndex, "message", messageKey, request.set),
+                                    };
+                                    return [4 /*yield*/, writer.write(oldDetailPath, detail)];
+                                case 4:
+                                    _e.sent();
+                                    return [4 /*yield*/, writeHistoryPages(writer, path.join(dataDirectoryPath, "history", "message", encodeKey(messageKey)), getHistoryForEntity(session.historyIndex, "message", messageKey, request.set), { skipEmpty: true })];
+                                case 5:
+                                    _e.sent();
+                                    nextSummary = summarizeMessage(message, messageKey, session.historyIndex, request.set, messageTargets);
+                                    existingSummaryIndex = index.entities.message.findIndex(function (entry) { return entry.key === messageKey; });
+                                    if (existingSummaryIndex === -1) {
+                                        index.entities.message.push(nextSummary);
+                                    }
+                                    else {
+                                        index.entities.message[existingSummaryIndex] = nextSummary;
+                                    }
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _i = 0, _c = request.messageKeys;
+                    _d.label = 4;
+                case 4:
+                    if (!(_i < _c.length)) return [3 /*break*/, 7];
+                    messageKey = _c[_i];
+                    return [5 /*yield**/, _loop_1(messageKey)];
+                case 5:
+                    state_1 = _d.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    _d.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    index.entities.message.sort(function (left, right) { return left.key.localeCompare(right.key); });
+                    index.counts.message = messageKeys.length;
+                    return [4 /*yield*/, writer.write(indexPath, index)];
+                case 8:
+                    _d.sent();
+                    return [2 /*return*/, true];
+            }
+        });
+    });
+}
+function rebuildCatalogSetForDev(runtime, rootDirectoryPath, projectConfig, datasource, session, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var writer, progress, executions, setIndexes, existingIndexes, _i, existingIndexes_1, _a, key, index, execution, outputRelativeDirectory, context, _b, _c;
+        var _this = this;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    writer = new CatalogJsonWriter();
+                    progress = new CatalogProgressReporter(rootDirectoryPath, session.outputDirectoryPath);
+                    return [4 /*yield*/, runtime.getProjectSetExecutions(projectConfig, datasource)];
+                case 1:
+                    executions = _d.sent();
+                    setIndexes = {};
+                    return [4 /*yield*/, Promise.all(executions.map(function (execution) { return __awaiter(_this, void 0, void 0, function () {
+                            var indexPath, _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        indexPath = path.join(session.outputDirectoryPath, "data", getOutputRelativeDirectory(projectConfig, execution.set), "index.json");
+                                        _a = [execution.set || "root"];
+                                        return [4 /*yield*/, readJsonFile(indexPath)];
+                                    case 1: return [2 /*return*/, _a.concat([_b.sent()])];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    existingIndexes = _d.sent();
+                    for (_i = 0, existingIndexes_1 = existingIndexes; _i < existingIndexes_1.length; _i++) {
+                        _a = existingIndexes_1[_i], key = _a[0], index = _a[1];
+                        if (index) {
+                            setIndexes[key] = index;
+                        }
+                    }
+                    execution = executions.find(function (item) { return (item.set || undefined) === options.set; });
+                    if (!execution) {
+                        return [2 /*return*/, false];
+                    }
+                    outputRelativeDirectory = getOutputRelativeDirectory(projectConfig, execution.set);
+                    return [4 /*yield*/, fs.promises.rm(path.join(session.outputDirectoryPath, "data", outputRelativeDirectory), {
+                            recursive: true,
+                            force: true,
+                        })];
+                case 3:
+                    _d.sent();
+                    context = {
+                        rootDirectoryPath: rootDirectoryPath,
+                        repositoryRootDirectoryPath: session.repositoryRootDirectoryPath,
+                        repositorySourceRootDirectoryPath: session.repositorySourceRootDirectoryPath,
+                        outputDirectoryPath: session.outputDirectoryPath,
+                        dataDirectoryPath: path.join(session.outputDirectoryPath, "data"),
+                        historyIndex: session.historyIndex,
+                        runtime: runtime,
+                        devEditors: session.devEditors,
+                        duplicateResultsBySet: {},
+                        withTranslationSearch: options.withTranslationSearch,
+                        withDuplicates: options.withDuplicates,
+                        progress: progress,
+                        writer: writer,
+                    };
+                    _b = setIndexes;
+                    _c = execution.set || "root";
+                    return [4 /*yield*/, buildSetCatalog(context, execution.set, execution.projectConfig, execution.datasource, outputRelativeDirectory)];
+                case 4:
+                    _b[_c] = _d.sent();
+                    return [4 /*yield*/, writeCatalogManifest(writer, rootDirectoryPath, projectConfig, session, {
+                            browserRouter: options.browserRouter,
+                            withTranslationSearch: options.withTranslationSearch,
+                            withDuplicates: options.withDuplicates,
+                            setIndexes: setIndexes,
+                            executions: executions,
+                        })];
+                case 5:
+                    _d.sent();
+                    return [2 /*return*/, true];
+            }
+        });
+    });
+}
 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, withTranslationSearch, withDuplicates, progress, writer, stepStartedAt, devEditors, historyIndex, links, duplicateResultsBySet, _a, _b, context, executions, setIndexes, _i, executions_1, execution, outputRelativeDirectory, _c, _d, manifest;
+        var outputDirectoryPath, dataDirectoryPath, withTranslationSearch, withDuplicates, progress, writer, stepStartedAt, devEditors, historyIndex, _a, links, duplicateResultsBySet, _b, _c, context, executions, setIndexes, _i, executions_1, execution, outputRelativeDirectory, _d, _e, manifest;
+        var _f, _g, _h, _j, _k;
         if (options === void 0) { options = {}; }
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        return __generator(this, function (_l) {
+            switch (_l.label) {
                 case 0:
                     outputDirectoryPath = options.outDir
                         ? path.resolve(rootDirectoryPath, options.outDir)
@@ -1524,37 +1916,50 @@ function exportCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasour
                         features: __spreadArray(__spreadArray([], (withTranslationSearch ? ["translation search"] : []), true), (withDuplicates ? ["duplicates"] : []), true),
                     });
                     stepStartedAt = progress.step("Preparing output directory");
-                    return [4 /*yield*/, fs.promises.rm(outputDirectoryPath, { recursive: true, force: true })];
+                    if (!options.preserveAssets) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fs.promises.rm(dataDirectoryPath, { recursive: true, force: true })];
                 case 1:
-                    _e.sent();
-                    return [4 /*yield*/, fs.promises.mkdir(dataDirectoryPath, { recursive: true })];
-                case 2:
-                    _e.sent();
+                    _l.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, fs.promises.rm(outputDirectoryPath, { recursive: true, force: true })];
+                case 3:
+                    _l.sent();
+                    _l.label = 4;
+                case 4: return [4 /*yield*/, fs.promises.mkdir(dataDirectoryPath, { recursive: true })];
+                case 5:
+                    _l.sent();
                     progress.done(stepStartedAt);
-                    if (!(options.copyAssets !== false)) return [3 /*break*/, 4];
+                    if (!(options.copyAssets !== false)) return [3 /*break*/, 7];
                     stepStartedAt = progress.step("Copying Catalog UI assets");
                     return [4 /*yield*/, copyCatalogAssets(outputDirectoryPath)];
-                case 3:
-                    _e.sent();
+                case 6:
+                    _l.sent();
                     progress.done(stepStartedAt);
-                    _e.label = 4;
-                case 4:
-                    devEditors = options.dev ? options.devEditors || detectDevEditors() : [];
+                    _l.label = 7;
+                case 7:
+                    devEditors = options.dev
+                        ? ((_f = options.devSession) === null || _f === void 0 ? void 0 : _f.devEditors) || options.devEditors || detectDevEditors()
+                        : [];
                     stepStartedAt = progress.step("Reading Git history");
+                    _a = ((_g = options.devSession) === null || _g === void 0 ? void 0 : _g.historyIndex);
+                    if (_a) return [3 /*break*/, 9];
                     return [4 /*yield*/, getGitHistoryIndex(rootDirectoryPath, projectConfig)];
-                case 5:
-                    historyIndex = _e.sent();
+                case 8:
+                    _a = (_l.sent());
+                    _l.label = 9;
+                case 9:
+                    historyIndex = _a;
                     progress.done(stepStartedAt, "(".concat(pluralize(historyIndex.entries.length, "commit"), ")"));
                     stepStartedAt = progress.step("Resolving repository links");
-                    links = getRepoLinks(rootDirectoryPath);
+                    links = ((_h = options.devSession) === null || _h === void 0 ? void 0 : _h.links) || getRepoLinks(rootDirectoryPath);
                     progress.done(stepStartedAt);
                     duplicateResultsBySet = {};
-                    if (!withDuplicates) return [3 /*break*/, 7];
+                    if (!withDuplicates) return [3 /*break*/, 11];
                     stepStartedAt = progress.step("Scanning duplicate translations");
-                    _b = (_a = Object).fromEntries;
+                    _c = (_b = Object).fromEntries;
                     return [4 /*yield*/, runtime.findDuplicateTranslations(projectConfig, datasource)];
-                case 6:
-                    duplicateResultsBySet = _b.apply(_a, [(_e.sent()).results.map(function (result) { return [
+                case 10:
+                    duplicateResultsBySet = _c.apply(_b, [(_l.sent()).results.map(function (result) { return [
                             getDuplicateSetKey(result.set),
                             result,
                         ]; })]);
@@ -1562,12 +1967,14 @@ function exportCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasour
                         return total +
                             result.locales.reduce(function (localeTotal, localeResult) { return localeTotal + localeResult.duplicateValues.length; }, 0);
                     }, 0), "duplicate value"), ")"));
-                    _e.label = 7;
-                case 7:
+                    _l.label = 11;
+                case 11:
                     context = {
                         rootDirectoryPath: rootDirectoryPath,
-                        repositoryRootDirectoryPath: getRepositoryRootDirectoryPath(rootDirectoryPath),
-                        repositorySourceRootDirectoryPath: getRepositorySourceRootDirectoryPath(rootDirectoryPath),
+                        repositoryRootDirectoryPath: ((_j = options.devSession) === null || _j === void 0 ? void 0 : _j.repositoryRootDirectoryPath) ||
+                            getRepositoryRootDirectoryPath(rootDirectoryPath),
+                        repositorySourceRootDirectoryPath: ((_k = options.devSession) === null || _k === void 0 ? void 0 : _k.repositorySourceRootDirectoryPath) ||
+                            getRepositorySourceRootDirectoryPath(rootDirectoryPath),
                         outputDirectoryPath: outputDirectoryPath,
                         dataDirectoryPath: dataDirectoryPath,
                         historyIndex: historyIndex,
@@ -1581,33 +1988,33 @@ function exportCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasour
                     };
                     stepStartedAt = progress.step("Discovering project sets");
                     return [4 /*yield*/, runtime.getProjectSetExecutions(projectConfig, datasource)];
-                case 8:
-                    executions = _e.sent();
+                case 12:
+                    executions = _l.sent();
                     progress.done(stepStartedAt, projectConfig.sets
                         ? "(".concat(executions.map(function (execution) { return execution.set; }).join(", ") || "none", ")")
                         : "(root)");
                     setIndexes = {};
                     stepStartedAt = progress.step("Writing project history");
                     return [4 /*yield*/, writeHistoryPages(writer, path.join(dataDirectoryPath, "project", "history"), historyIndex.entries)];
-                case 9:
-                    _e.sent();
+                case 13:
+                    _l.sent();
                     progress.done(stepStartedAt, "(".concat(pluralize(historyIndex.entries.length, "entry", "entries"), ")"));
                     _i = 0, executions_1 = executions;
-                    _e.label = 10;
-                case 10:
-                    if (!(_i < executions_1.length)) return [3 /*break*/, 13];
+                    _l.label = 14;
+                case 14:
+                    if (!(_i < executions_1.length)) return [3 /*break*/, 17];
                     execution = executions_1[_i];
                     outputRelativeDirectory = projectConfig.sets ? path.join("sets", execution.set) : "root";
-                    _c = setIndexes;
-                    _d = execution.set || "root";
+                    _d = setIndexes;
+                    _e = execution.set || "root";
                     return [4 /*yield*/, buildSetCatalog(context, execution.set, execution.projectConfig, execution.datasource, outputRelativeDirectory)];
-                case 11:
-                    _c[_d] = _e.sent();
-                    _e.label = 12;
-                case 12:
+                case 15:
+                    _d[_e] = _l.sent();
+                    _l.label = 16;
+                case 16:
                     _i++;
-                    return [3 /*break*/, 10];
-                case 13:
+                    return [3 /*break*/, 14];
+                case 17:
                     stepStartedAt = progress.step("Writing manifest");
                     manifest = {
                         schemaVersion: exports.CATALOG_SCHEMA_VERSION,
@@ -1634,8 +2041,8 @@ function exportCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasour
                         counts: Object.fromEntries(Object.keys(setIndexes).map(function (key) { return [key, setIndexes[key].counts]; })),
                     };
                     return [4 /*yield*/, writer.write(path.join(dataDirectoryPath, "manifest.json"), manifest)];
-                case 14:
-                    _e.sent();
+                case 18:
+                    _l.sent();
                     progress.done(stepStartedAt);
                     progress.complete();
                     return [2 /*return*/, {
@@ -1686,7 +2093,17 @@ function injectCatalogLiveReloadClient(html) {
     }
     return "".concat(html).concat(script);
 }
-function createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, onChange) {
+function getCatalogInputWatchPaths(rootDirectoryPath, projectConfig) {
+    var paths = [path.join(rootDirectoryPath, "messagevisor.config.js")];
+    if (projectConfig.sets) {
+        paths.push(projectConfig.setsDirectoryPath);
+        return paths;
+    }
+    paths.push(projectConfig.localesDirectoryPath, projectConfig.messagesDirectoryPath, projectConfig.attributesDirectoryPath, projectConfig.segmentsDirectoryPath, projectConfig.targetsDirectoryPath, projectConfig.testsDirectoryPath);
+    return paths.filter(function (entry) { return typeof entry === "string" && entry.length > 0; });
+}
+function createCatalogInputWatcher(rootDirectoryPath, projectConfig, ignoredDirectoryPaths, onChange) {
+    var watchPaths = getCatalogInputWatchPaths(rootDirectoryPath, projectConfig);
     function shouldIgnore(targetPath) {
         var resolvedTargetPath = path.resolve(targetPath);
         return ignoredDirectoryPaths.some(function (ignoredDirectoryPath) {
@@ -1695,6 +2112,17 @@ function createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, onChange
                 resolvedTargetPath.startsWith("".concat(resolvedIgnoredPath).concat(path.sep)));
         });
     }
+    function shouldWatch(targetPath) {
+        var resolvedTargetPath = path.resolve(targetPath);
+        if (shouldIgnore(resolvedTargetPath)) {
+            return false;
+        }
+        return watchPaths.some(function (watchPath) {
+            var resolvedWatchPath = path.resolve(watchPath);
+            return (resolvedTargetPath === resolvedWatchPath ||
+                resolvedTargetPath.startsWith("".concat(resolvedWatchPath).concat(path.sep)));
+        });
+    }
     function collectSnapshotEntries(directoryPath, snapshotEntries) {
         if (shouldIgnore(directoryPath)) {
             return;
@@ -1721,8 +2149,7 @@ function createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, onChange
             }
             try {
                 var stat = fs.statSync(entryPath);
-                var relativePath = path.relative(rootDirectoryPath, entryPath);
-                snapshotEntries.push("".concat(relativePath, ":").concat(stat.size, ":").concat(stat.mtimeMs));
+                snapshotEntries.set(entryPath, "".concat(stat.size, ":").concat(stat.mtimeMs));
             }
             catch (_b) {
                 // Ignore transient editor save races.
@@ -1730,22 +2157,94 @@ function createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, onChange
         }
     }
     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;
+        var snapshotEntries = new Map();
+        for (var _i = 0, watchPaths_2 = watchPaths; _i < watchPaths_2.length; _i++) {
+            var watchPath = watchPaths_2[_i];
+            if (!fs.existsSync(watchPath)) {
+                continue;
+            }
+            var stat = fs.statSync(watchPath);
+            if (stat.isFile()) {
+                snapshotEntries.set(watchPath, "".concat(stat.size, ":").concat(stat.mtimeMs));
+                continue;
+            }
+            collectSnapshotEntries(watchPath, snapshotEntries);
+        }
+        return snapshotEntries;
+    }
+    function getSnapshotChanges(previous, next) {
+        var changedPaths = new Set();
+        for (var _i = 0, _a = Array.from(next.entries()); _i < _a.length; _i++) {
+            var _b = _a[_i], filePath = _b[0], signature = _b[1];
+            if (previous.get(filePath) !== signature) {
+                changedPaths.add(filePath);
+            }
+        }
+        for (var _c = 0, _d = Array.from(previous.keys()); _c < _d.length; _c++) {
+            var filePath = _d[_c];
+            if (!next.has(filePath)) {
+                changedPaths.add(filePath);
+            }
+        }
+        return Array.from(changedPaths);
+    }
+    function createPollingWatcher() {
+        var previousSnapshot = createSnapshot();
+        var interval = setInterval(function () {
+            var nextSnapshot = createSnapshot();
+            var changedPaths = getSnapshotChanges(previousSnapshot, nextSnapshot).filter(shouldWatch);
+            previousSnapshot = nextSnapshot;
+            if (changedPaths.length === 0) {
+                return;
+            }
+            onChange(changedPaths);
+        }, 1000);
+        return function () {
+            clearInterval(interval);
+        };
+    }
+    var watchers = [];
+    var nativeWatcherFailed = false;
+    var _loop_2 = function (watchPath) {
+        if (!fs.existsSync(watchPath)) {
+            return "continue";
+        }
+        try {
+            var stat = fs.statSync(watchPath);
+            var directoryPath_1 = stat.isDirectory() ? watchPath : path.dirname(watchPath);
+            var watcher = fs.watch(directoryPath_1, { recursive: stat.isDirectory() }, function (_eventType, filename) {
+                var changedPath = filename
+                    ? path.resolve(directoryPath_1, filename.toString())
+                    : directoryPath_1;
+                if (shouldWatch(changedPath)) {
+                    onChange([changedPath]);
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch (_error) {
+            nativeWatcherFailed = true;
+            return "break";
         }
-        previousSnapshot = nextSnapshot;
-        onChange(rootDirectoryPath);
-    }, 250);
+    };
+    for (var _i = 0, watchPaths_1 = watchPaths; _i < watchPaths_1.length; _i++) {
+        var watchPath = watchPaths_1[_i];
+        var state_2 = _loop_2(watchPath);
+        if (state_2 === "break")
+            break;
+    }
+    if (nativeWatcherFailed || watchers.length === 0) {
+        for (var _a = 0, watchers_1 = watchers; _a < watchers_1.length; _a++) {
+            var watcher = watchers_1[_a];
+            watcher.close();
+        }
+        return createPollingWatcher();
+    }
     return function () {
-        clearInterval(interval);
+        for (var _i = 0, watchers_2 = watchers; _i < watchers_2.length; _i++) {
+            var watcher = watchers_2[_i];
+            watcher.close();
+        }
     };
 }
 function serveCatalog(runtime_1, rootDirectoryPath_1, projectConfig_1, datasource_1) {
@@ -1874,13 +2373,17 @@ function isWithTranslationSearchEnabled(parsed) {
 function isWithDuplicatesEnabled(parsed) {
     return parsed.withDuplicates === true || parsed["with-duplicates"] === true;
 }
+exports.__catalogDevInternals = {
+    classifyCatalogDevChanges: classifyCatalogDevChanges,
+    getCatalogInputWatchPaths: getCatalogInputWatchPaths,
+};
 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, withTranslationSearch, withDuplicates, server_1, outputDirectoryPath, ignoredDirectoryPaths, exportInFlight_1, exportQueued_1, queuedReason_1, debounceTimer_1, runExportAndReload_1, stopWatchingProject;
+            var allowedSubcommands, browserRouter, withTranslationSearch, withDuplicates, outputDirectoryPath, devSession_1, server_1, ignoredDirectoryPaths, exportInFlight_1, queuedChanges_1, pendingChanges_1, debounceTimer_1, runRebuildAndReload_1, stopWatchingProject;
             var _this = this;
             var rootDirectoryPath = _b.rootDirectoryPath, projectConfig = _b.projectConfig, datasource = _b.datasource, parsed = _b.parsed;
             return __generator(this, function (_c) {
@@ -1890,16 +2393,25 @@ function createCatalogPlugin(runtime, api) {
                         browserRouter = !(parsed.hashRouter || parsed["hash-router"]);
                         withTranslationSearch = isWithTranslationSearchEnabled(parsed);
                         withDuplicates = isWithDuplicatesEnabled(parsed);
-                        if (!!parsed.subcommand) return [3 /*break*/, 3];
+                        if (!!parsed.subcommand) return [3 /*break*/, 4];
+                        outputDirectoryPath = parsed.outDir
+                            ? path.resolve(rootDirectoryPath, parsed.outDir)
+                            : projectConfig.catalogDirectoryPath;
+                        return [4 /*yield*/, createCatalogDevSession(rootDirectoryPath, projectConfig, {
+                                outDir: parsed.outDir,
+                            })];
+                    case 1:
+                        devSession_1 = _c.sent();
                         return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
                                 outDir: parsed.outDir,
                                 copyAssets: !parsed.noAssets,
                                 browserRouter: browserRouter,
                                 dev: true,
+                                devSession: devSession_1,
                                 withTranslationSearch: withTranslationSearch,
                                 withDuplicates: withDuplicates,
                             })];
-                    case 1:
+                    case 2:
                         _c.sent();
                         return [4 /*yield*/, api.serveCatalog(rootDirectoryPath, projectConfig, datasource, {
                                 outDir: parsed.outDir,
@@ -1907,11 +2419,8 @@ function createCatalogPlugin(runtime, api) {
                                 browserRouter: browserRouter,
                                 liveReload: true,
                             })];
-                    case 2:
+                    case 3:
                         server_1 = _c.sent();
-                        outputDirectoryPath = parsed.outDir
-                            ? path.resolve(rootDirectoryPath, parsed.outDir)
-                            : projectConfig.catalogDirectoryPath;
                         ignoredDirectoryPaths = [
                             path.join(rootDirectoryPath, ".git"),
                             path.join(rootDirectoryPath, "node_modules"),
@@ -1923,72 +2432,102 @@ function createCatalogPlugin(runtime, api) {
                             outputDirectoryPath,
                         ];
                         exportInFlight_1 = false;
-                        exportQueued_1 = false;
-                        queuedReason_1 = null;
+                        queuedChanges_1 = [];
+                        pendingChanges_1 = [];
                         debounceTimer_1 = null;
-                        runExportAndReload_1 = function (reason) { return __awaiter(_this, void 0, void 0, function () {
-                            var error_1, nextReason;
+                        runRebuildAndReload_1 = function (changedPaths) { return __awaiter(_this, void 0, void 0, function () {
+                            var request, handled, execution, error_1, nextChanges;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         if (exportInFlight_1) {
-                                            exportQueued_1 = true;
-                                            queuedReason_1 = queuedReason_1 || reason;
+                                            queuedChanges_1.push.apply(queuedChanges_1, changedPaths);
                                             return [2 /*return*/];
                                         }
                                         exportInFlight_1 = true;
-                                        console.log("\n[catalog] Re-exporting because ".concat(reason));
+                                        request = classifyCatalogDevChanges(rootDirectoryPath, projectConfig, changedPaths, {
+                                            withTranslationSearch: withTranslationSearch,
+                                            withDuplicates: withDuplicates,
+                                        });
+                                        console.log("\n[catalog] Rebuilding (".concat(request.kind, ") because ").concat(request.reason));
                                         _a.label = 1;
                                     case 1:
-                                        _a.trys.push([1, 3, 4, 5]);
+                                        _a.trys.push([1, 9, 10, 11]);
+                                        handled = false;
+                                        if (!(request.kind === "message")) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, runtime.getProjectSetExecutions(projectConfig, datasource, request.set)];
+                                    case 2:
+                                        execution = (_a.sent())[0];
+                                        return [4 /*yield*/, tryRebuildCatalogMessage(runtime, rootDirectoryPath, projectConfig, execution.projectConfig, execution.datasource, devSession_1, request)];
+                                    case 3:
+                                        handled = _a.sent();
+                                        _a.label = 4;
+                                    case 4:
+                                        if (!(!handled && request.kind === "set" && request.set)) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, rebuildCatalogSetForDev(runtime, rootDirectoryPath, projectConfig, datasource, devSession_1, {
+                                                set: request.set,
+                                                browserRouter: browserRouter,
+                                                withTranslationSearch: withTranslationSearch,
+                                                withDuplicates: withDuplicates,
+                                            })];
+                                    case 5:
+                                        handled = _a.sent();
+                                        _a.label = 6;
+                                    case 6:
+                                        if (!!handled) return [3 /*break*/, 8];
                                         return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
                                                 outDir: parsed.outDir,
-                                                copyAssets: !parsed.noAssets,
+                                                copyAssets: false,
+                                                preserveAssets: true,
                                                 browserRouter: browserRouter,
                                                 dev: true,
+                                                devSession: devSession_1,
                                                 withTranslationSearch: withTranslationSearch,
                                                 withDuplicates: withDuplicates,
                                             })];
-                                    case 2:
+                                    case 7:
                                         _a.sent();
+                                        _a.label = 8;
+                                    case 8:
                                         server_1.triggerReload();
-                                        return [3 /*break*/, 5];
-                                    case 3:
+                                        return [3 /*break*/, 11];
+                                    case 9:
                                         error_1 = _a.sent();
                                         console.error("[catalog] Export failed during watch mode");
                                         console.error(error_1);
-                                        return [3 /*break*/, 5];
-                                    case 4:
+                                        return [3 /*break*/, 11];
+                                    case 10:
                                         exportInFlight_1 = false;
-                                        if (exportQueued_1) {
-                                            nextReason = queuedReason_1 || "more project changes";
-                                            exportQueued_1 = false;
-                                            queuedReason_1 = null;
-                                            void runExportAndReload_1(nextReason);
+                                        if (queuedChanges_1.length > 0) {
+                                            nextChanges = queuedChanges_1;
+                                            queuedChanges_1 = [];
+                                            void runRebuildAndReload_1(nextChanges);
                                         }
                                         return [7 /*endfinally*/];
-                                    case 5: return [2 /*return*/];
+                                    case 11: return [2 /*return*/];
                                 }
                             });
                         }); };
-                        stopWatchingProject = createProjectWatcher(rootDirectoryPath, ignoredDirectoryPaths, function (changedPath) {
-                            var reason = "project change in ".concat(path.relative(rootDirectoryPath, changedPath) || ".");
+                        stopWatchingProject = createCatalogInputWatcher(rootDirectoryPath, projectConfig, ignoredDirectoryPaths, function (changedPaths) {
+                            pendingChanges_1.push.apply(pendingChanges_1, changedPaths);
                             if (debounceTimer_1) {
                                 clearTimeout(debounceTimer_1);
                             }
                             debounceTimer_1 = setTimeout(function () {
+                                var nextChanges = Array.from(new Set(pendingChanges_1));
+                                pendingChanges_1 = [];
                                 debounceTimer_1 = null;
-                                void runExportAndReload_1(reason);
-                            }, 150);
+                                void runRebuildAndReload_1(nextChanges);
+                            }, 250);
                         });
                         process.on("exit", stopWatchingProject);
                         return [2 /*return*/];
-                    case 3:
+                    case 4:
                         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];
+                        if (!(parsed.subcommand === "export")) return [3 /*break*/, 6];
                         return [4 /*yield*/, api.exportCatalog(rootDirectoryPath, projectConfig, datasource, {
                                 outDir: parsed.outDir,
                                 copyAssets: !parsed.noAssets,
@@ -1996,20 +2535,20 @@ function createCatalogPlugin(runtime, api) {
                                 withTranslationSearch: withTranslationSearch,
                                 withDuplicates: withDuplicates,
                             })];
-                    case 4:
-                        _c.sent();
-                        _c.label = 5;
                     case 5:
-                        if (!(parsed.subcommand === "serve")) return [3 /*break*/, 7];
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        if (!(parsed.subcommand === "serve")) return [3 /*break*/, 8];
                         return [4 /*yield*/, api.serveCatalog(rootDirectoryPath, projectConfig, datasource, {
                                 outDir: parsed.outDir,
                                 port: parsed.port || parsed.p,
                                 browserRouter: browserRouter,
                             })];
-                    case 6:
+                    case 7:
                         _c.sent();
-                        _c.label = 7;
-                    case 7: return [2 /*return*/];
+                        _c.label = 8;
+                    case 8: return [2 /*return*/];
                 }
             });
         }); },