@messagevisor/core 0.0.1 → 0.1.0

package/lib/promoter/index.js

@@ -0,0 +1,1208 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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.promotePlugin = void 0;
+exports.promoteProjectSets = promoteProjectSets;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+var error_1 = require("../error");
+var linter_1 = require("../linter");
+var cliFormat_1 = require("../tester/cliFormat");
+var prettyDuration_1 = require("../tester/prettyDuration");
+function isPromotable(entity) {
+    return (entity === null || entity === void 0 ? void 0 : entity.promotable) !== false;
+}
+function assertAllowedPromotionFlow(projectConfig, from, to) {
+    var allowedFlows = projectConfig.promotionFlows;
+    if (typeof allowedFlows === "undefined") {
+        return;
+    }
+    var isAllowed = allowedFlows.some(function (flow) { return flow.from === from && flow.to === to; });
+    if (isAllowed) {
+        return;
+    }
+    var allowedList = allowedFlows.map(function (flow) { return "".concat(flow.from, " -> ").concat(flow.to); }).join(", ") || "none";
+    throw new error_1.MessagevisorCLIError("Promotion from \"".concat(from, "\" to \"").concat(to, "\" is not allowed by this project's configured promotionFlows.\nAllowed flows: ").concat(allowedList, ".\nChoose one of the allowed promotion paths or update messagevisor.config.js if this flow should be permitted."));
+}
+function toArray(value) {
+    if (typeof value === "undefined") {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function getArrayEntryIdentity(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    if (typeof value.description === "string") {
+        return "description:".concat(value.description);
+    }
+    var identity = {};
+    for (var _i = 0, _a = [
+        "locale",
+        "target",
+        "segment",
+        "context",
+        "values",
+        "withFlags",
+        "withVariations",
+        "currency",
+        "timeZone",
+    ]; _i < _a.length; _i++) {
+        var key = _a[_i];
+        if (typeof value[key] !== "undefined") {
+            identity[key] = value[key];
+        }
+    }
+    return Object.keys(identity).length > 0 ? JSON.stringify(identity) : undefined;
+}
+function deepMerge(destination, source) {
+    if (typeof destination === "undefined")
+        return source;
+    if (typeof source === "undefined")
+        return destination;
+    if (Array.isArray(destination) && Array.isArray(source)) {
+        var result = __spreadArray([], source, true);
+        var sourceIdentities = new Set(source.map(getArrayEntryIdentity).filter(function (value) { return Boolean(value); }));
+        var _loop_1 = function (entry) {
+            var identity = getArrayEntryIdentity(entry);
+            if (!identity && !result.some(function (item) { return deepEqual(item, entry); })) {
+                result.push(entry);
+            }
+            else if (identity &&
+                !sourceIdentities.has(identity) &&
+                !result.some(function (item) { return getArrayEntryIdentity(item) === identity; })) {
+                result.push(entry);
+            }
+        };
+        for (var _i = 0, destination_1 = destination; _i < destination_1.length; _i++) {
+            var entry = destination_1[_i];
+            _loop_1(entry);
+        }
+        return result;
+    }
+    if (isPlainObject(destination) && isPlainObject(source)) {
+        var result = __assign({}, destination);
+        for (var _a = 0, _b = Object.keys(source); _a < _b.length; _a++) {
+            var key = _b[_a];
+            result[key] = deepMerge(result[key], source[key]);
+        }
+        return result;
+    }
+    return source;
+}
+function deepMergeWithPolicy(destination, source, policy, conflicts, pathSegments) {
+    if (pathSegments === void 0) { pathSegments = []; }
+    if (typeof destination === "undefined")
+        return source;
+    if (typeof source === "undefined")
+        return destination;
+    var conflictPath = pathSegments.join(".") || "<root>";
+    if (Array.isArray(destination) && Array.isArray(source)) {
+        if (!deepEqual(destination, source)) {
+            conflicts.push({ path: conflictPath, source: source, destination: destination });
+        }
+        if (policy === "destination") {
+            var result = __spreadArray([], destination, true);
+            var destinationIdentities = new Set(destination.map(getArrayEntryIdentity).filter(function (value) { return Boolean(value); }));
+            var _loop_2 = function (entry) {
+                var identity = getArrayEntryIdentity(entry);
+                if (!identity && !result.some(function (item) { return deepEqual(item, entry); })) {
+                    result.push(entry);
+                }
+                else if (identity &&
+                    !destinationIdentities.has(identity) &&
+                    !result.some(function (item) { return getArrayEntryIdentity(item) === identity; })) {
+                    result.push(entry);
+                }
+            };
+            for (var _i = 0, source_1 = source; _i < source_1.length; _i++) {
+                var entry = source_1[_i];
+                _loop_2(entry);
+            }
+            return result;
+        }
+        return deepMerge(destination, source);
+    }
+    if (isPlainObject(destination) && isPlainObject(source)) {
+        var result = __assign({}, destination);
+        for (var _a = 0, _b = Object.keys(source); _a < _b.length; _a++) {
+            var key = _b[_a];
+            result[key] = deepMergeWithPolicy(result[key], source[key], policy, conflicts, __spreadArray(__spreadArray([], pathSegments, true), [
+                key,
+            ], false));
+        }
+        return result;
+    }
+    if (!deepEqual(destination, source)) {
+        conflicts.push({ path: conflictPath, source: source, destination: destination });
+    }
+    return policy === "destination" ? destination : source;
+}
+function matchesPattern(key, patterns) {
+    if (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 withoutKey(entity) {
+    var _key = entity.key, rest = __rest(entity, ["key"]);
+    return rest;
+}
+function filterLocaleMap(values, locales) {
+    if (!values || locales.size === 0) {
+        return values;
+    }
+    return Object.fromEntries(Object.entries(values).filter(function (_a) {
+        var locale = _a[0];
+        return locales.has(locale);
+    }));
+}
+function collectGroupSegmentKeys(value, result) {
+    if (!value || value === "*")
+        return;
+    if (typeof value === "string") {
+        result.add(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach(function (entry) { return collectGroupSegmentKeys(entry, result); });
+        return;
+    }
+    if (value.and)
+        value.and.forEach(function (entry) { return collectGroupSegmentKeys(entry, result); });
+    if (value.or)
+        value.or.forEach(function (entry) { return collectGroupSegmentKeys(entry, result); });
+    if (value.not)
+        value.not.forEach(function (entry) { return collectGroupSegmentKeys(entry, result); });
+}
+function collectConditionDependencies(value, segments, attributes) {
+    if (!value || value === "*")
+        return;
+    if (typeof value === "string") {
+        segments.add(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach(function (entry) { return collectConditionDependencies(entry, segments, attributes); });
+        return;
+    }
+    if ("attribute" in value) {
+        attributes.add(value.attribute.split(".")[0]);
+        return;
+    }
+    if ("and" in value)
+        value.and.forEach(function (entry) { return collectConditionDependencies(entry, segments, attributes); });
+    if ("or" in value)
+        value.or.forEach(function (entry) { return collectConditionDependencies(entry, segments, attributes); });
+    if ("not" in value)
+        value.not.forEach(function (entry) { return collectConditionDependencies(entry, segments, attributes); });
+}
+function mergeMessage(messageKey, destination, source, policy, conflicts) {
+    if (!destination) {
+        return source;
+    }
+    validateMessageOverrideKeys(messageKey, destination);
+    var sourceOverrides = source.overrides || [];
+    var destinationOverrides = destination.overrides || [];
+    var mergedOverrideKeys = new Set();
+    var overrides = sourceOverrides.map(function (sourceOverride) {
+        var destinationOverride = destinationOverrides.find(function (override) { return override.key === sourceOverride.key; });
+        mergedOverrideKeys.add(sourceOverride.key);
+        var overrideConflicts = [];
+        var merged = deepMergeWithPolicy(destinationOverride, sourceOverride, policy, overrideConflicts, ["overrides", sourceOverride.key]);
+        conflicts.push.apply(conflicts, overrideConflicts.map(function (conflict) { return (__assign({ type: "message", key: messageKey }, conflict)); }));
+        return merged;
+    });
+    for (var _i = 0, destinationOverrides_1 = destinationOverrides; _i < destinationOverrides_1.length; _i++) {
+        var destinationOverride = destinationOverrides_1[_i];
+        if (!mergedOverrideKeys.has(destinationOverride.key)) {
+            overrides.push(destinationOverride);
+        }
+    }
+    var messageConflicts = [];
+    var mergedMessage = deepMergeWithPolicy(destination, __assign(__assign({}, source), { overrides: undefined }), policy, messageConflicts);
+    conflicts.push.apply(conflicts, messageConflicts.map(function (conflict) { return (__assign({ type: "message", key: messageKey }, conflict)); }));
+    return __assign(__assign({}, mergedMessage), { overrides: overrides.length > 0 ? overrides : undefined });
+}
+function removeMessageOverrides(message) {
+    var _overrides = message.overrides, messageWithoutOverrides = __rest(message, ["overrides"]);
+    return messageWithoutOverrides;
+}
+function filterMessageForLocales(message, locales) {
+    if (locales.size === 0) {
+        return message;
+    }
+    var overrides = (message.overrides || [])
+        .map(function (override) { return (__assign(__assign({}, override), { translations: filterLocaleMap(override.translations, locales) || {} })); })
+        .filter(function (override) { return Object.keys(override.translations).length > 0; });
+    return __assign(__assign({}, message), { translations: filterLocaleMap(message.translations, locales) || {}, overrides: overrides.length > 0 ? overrides : undefined });
+}
+function filterTargetForLocales(target, locales) {
+    var _a;
+    if (locales.size === 0) {
+        return target;
+    }
+    return __assign(__assign({}, target), { locales: (_a = target.locales) === null || _a === void 0 ? void 0 : _a.filter(function (locale) { return locales.has(locale); }), formats: filterLocaleMap(target.formats, locales) });
+}
+function filterTestForLocales(test, locales) {
+    if (locales.size === 0 || !Array.isArray(test.assertions)) {
+        return test;
+    }
+    return __assign(__assign({}, test), { assertions: test.assertions.filter(function (assertion) { return !assertion.locale || locales.has(assertion.locale); }) });
+}
+function validateMessageOverrideKeys(messageKey, message) {
+    var keys = new Set();
+    for (var index = 0; index < (message.overrides || []).length; index++) {
+        var override = (message.overrides || [])[index];
+        if (!override.key) {
+            throw new Error("Message \"".concat(messageKey, "\" override at index ").concat(index, " must define a key before promotion."));
+        }
+        if (keys.has(override.key)) {
+            throw new Error("Message \"".concat(messageKey, "\" has duplicate override key \"").concat(override.key, "\"."));
+        }
+        keys.add(override.key);
+    }
+}
+function safeRead(keys, read) {
+    return __awaiter(this, void 0, void 0, function () {
+        var entries;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(keys.map(function (key) { return __awaiter(_this, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = [key];
+                                return [4 /*yield*/, read(key)];
+                            case 1: return [2 /*return*/, _a.concat([_b.sent()])];
+                        }
+                    }); }); }))];
+                case 1:
+                    entries = _a.sent();
+                    return [2 /*return*/, Object.fromEntries(entries)];
+            }
+        });
+    });
+}
+function readDestination(key, read) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, read(key)];
+                case 1: return [2 /*return*/, _b.sent()];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, undefined];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function formatLintPreflightErrors(set, errors) {
+    var preview = errors
+        .slice(0, 5)
+        .map(function (error) { return "".concat(error.filePath, ": ").concat(error.message); })
+        .join("\n");
+    var suffix = errors.length > 5 ? "\n...and ".concat(errors.length - 5, " more") : "";
+    return "Set \"".concat(set, "\" failed preflight lint with ").concat(errors.length, " error(s).\n").concat(preview).concat(suffix);
+}
+function assertSetLintsClean(set, datasource) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, linter_1.lintProject)(datasource.getConfig(), datasource)];
+                case 1:
+                    result = _a.sent();
+                    if (result.hasError) {
+                        throw new Error(formatLintPreflightErrors(set, result.errors));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function getEntityFilePath(projectConfig, type, key) {
+    var directories = {
+        locale: projectConfig.localesDirectoryPath,
+        attribute: projectConfig.attributesDirectoryPath,
+        segment: projectConfig.segmentsDirectoryPath,
+        target: projectConfig.targetsDirectoryPath,
+        message: projectConfig.messagesDirectoryPath,
+        test: projectConfig.testsDirectoryPath,
+    };
+    var extension = projectConfig.parser.extension || "yml";
+    return (path.join.apply(path, __spreadArray([directories[type]], key.split(projectConfig.namespaceCharacter), false)) + ".".concat(extension));
+}
+function getPromotionPlan(sourceDatasource, destinationDatasource, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        function addLocaleWithAncestors(locale, result) {
+            if (!locales[locale] || result.has(locale))
+                return;
+            result.add(locale);
+            if (locales[locale].inheritFormatsFrom)
+                addLocaleWithAncestors(locales[locale].inheritFormatsFrom, result);
+            if (locales[locale].inheritTranslationsFrom)
+                addLocaleWithAncestors(locales[locale].inheritTranslationsFrom, result);
+        }
+        function plan(type_1, key_1, source_2, readDestinationEntity_1) {
+            return __awaiter(this, arguments, void 0, function (type, key, source, readDestinationEntity, merge) {
+                var cleanedSource, destination, cleanedDestination, conflicts, merged;
+                if (merge === void 0) { merge = function (destination, sourceValue, conflicts) {
+                    var entityConflicts = [];
+                    var merged = deepMergeWithPolicy(destination, sourceValue, options.conflicts, entityConflicts);
+                    conflicts.push.apply(conflicts, entityConflicts.map(function (conflict) { return (__assign({ type: type, key: key }, conflict)); }));
+                    return merged;
+                }; }
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            cleanedSource = withoutKey(source);
+                            return [4 /*yield*/, readDestination(key, readDestinationEntity)];
+                        case 1:
+                            destination = _a.sent();
+                            cleanedDestination = destination ? withoutKey(destination) : undefined;
+                            if (cleanedDestination && (!isPromotable(cleanedSource) || !isPromotable(cleanedDestination))) {
+                                plans.push({
+                                    type: type,
+                                    key: key,
+                                    source: cleanedSource,
+                                    destination: cleanedDestination,
+                                    merged: cleanedDestination,
+                                    conflicts: [],
+                                });
+                                return [2 /*return*/];
+                            }
+                            conflicts = [];
+                            merged = merge(cleanedDestination, cleanedSource, conflicts);
+                            plans.push({
+                                type: type,
+                                key: key,
+                                source: cleanedSource,
+                                destination: cleanedDestination,
+                                merged: merged,
+                                conflicts: conflicts,
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var selectedTargets, requestedLocales, includeMessages, excludeMessages, hasNoFilters, _a, localeKeys, targetKeys, messageKeys, segmentKeys, attributeKeys, testKeys, _i, _b, locale, _c, locales, targets, messages, segments, attributes, tests, promotedTargetKeys, promotedMessageKeys, explicitRuntimeLocales, matchedMessageCount, _d, messageKeys_1, messageKey, _e, _f, messageKey, _g, _h, messageKey, message, _j, _k, override, promotedLocaleKeys, localeFilterKeys, localeRestricted, localeSeeds, promotedSegmentKeys, promotedAttributeKeys, _l, _m, messageKey, message, _o, _p, override, pendingSegments, index, segmentKey, segment, beforeSize, promotedTestKeys, plans, _q, _r, key, _s, _t, key, _u, _v, key, targetLocaleFilter, _w, _x, key, messageLocaleFilter, _loop_3, _y, _z, key, _0, _1, key, test_1;
+        return __generator(this, function (_2) {
+            switch (_2.label) {
+                case 0:
+                    selectedTargets = new Set(toArray(options.target));
+                    requestedLocales = new Set(toArray(options.locale));
+                    includeMessages = toArray(options.includeMessages);
+                    excludeMessages = toArray(options.excludeMessages);
+                    hasNoFilters = selectedTargets.size === 0 && includeMessages.length === 0 && requestedLocales.size === 0;
+                    return [4 /*yield*/, Promise.all([
+                            sourceDatasource.listLocales(),
+                            sourceDatasource.listTargets(),
+                            sourceDatasource.listMessages(),
+                            sourceDatasource.listSegments(),
+                            sourceDatasource.listAttributes(),
+                            sourceDatasource.listTests(),
+                        ])];
+                case 1:
+                    _a = _2.sent(), localeKeys = _a[0], targetKeys = _a[1], messageKeys = _a[2], segmentKeys = _a[3], attributeKeys = _a[4], testKeys = _a[5];
+                    for (_i = 0, _b = Array.from(requestedLocales); _i < _b.length; _i++) {
+                        locale = _b[_i];
+                        if (!localeKeys.includes(locale)) {
+                            throw new Error("Unknown source locale \"".concat(locale, "\". Available locales: ").concat(localeKeys.join(", ") || "none", "."));
+                        }
+                    }
+                    return [4 /*yield*/, Promise.all([
+                            safeRead(localeKeys, function (key) { return sourceDatasource.readLocale(key); }),
+                            safeRead(targetKeys, function (key) { return sourceDatasource.readTarget(key); }),
+                            safeRead(messageKeys, function (key) { return sourceDatasource.readMessage(key); }),
+                            safeRead(segmentKeys, function (key) { return sourceDatasource.readSegment(key); }),
+                            safeRead(attributeKeys, function (key) { return sourceDatasource.readAttribute(key); }),
+                            safeRead(testKeys, function (key) { return sourceDatasource.readTest(key); }),
+                        ])];
+                case 2:
+                    _c = _2.sent(), locales = _c[0], targets = _c[1], messages = _c[2], segments = _c[3], attributes = _c[4], tests = _c[5];
+                    promotedTargetKeys = new Set();
+                    promotedMessageKeys = new Set();
+                    explicitRuntimeLocales = new Set();
+                    if (hasNoFilters) {
+                        targetKeys.forEach(function (key) { return promotedTargetKeys.add(key); });
+                        messageKeys.forEach(function (key) { return promotedMessageKeys.add(key); });
+                        localeKeys.forEach(function (key) { return explicitRuntimeLocales.add(key); });
+                    }
+                    else {
+                        selectedTargets.forEach(function (key) {
+                            var _a;
+                            if (!targets[key])
+                                throw new Error("Unknown source target \"".concat(key, "\"."));
+                            promotedTargetKeys.add(key);
+                            (targets[key].locales || localeKeys).forEach(function (locale) { return explicitRuntimeLocales.add(locale); });
+                            for (var _i = 0, messageKeys_2 = messageKeys; _i < messageKeys_2.length; _i++) {
+                                var messageKey = messageKeys_2[_i];
+                                var included = matchesPattern(messageKey, ((_a = targets[key].includeMessages) === null || _a === void 0 ? void 0 : _a.length) ? targets[key].includeMessages : ["*"]);
+                                var excluded = matchesPattern(messageKey, targets[key].excludeMessages || []);
+                                if (included && !excluded) {
+                                    promotedMessageKeys.add(messageKey);
+                                }
+                            }
+                        });
+                        if (includeMessages.length > 0) {
+                            matchedMessageCount = 0;
+                            for (_d = 0, messageKeys_1 = messageKeys; _d < messageKeys_1.length; _d++) {
+                                messageKey = messageKeys_1[_d];
+                                if (matchesPattern(messageKey, includeMessages) &&
+                                    !matchesPattern(messageKey, excludeMessages)) {
+                                    promotedMessageKeys.add(messageKey);
+                                    matchedMessageCount++;
+                                }
+                            }
+                            if (matchedMessageCount === 0 && !options.allowEmpty) {
+                                throw new Error("No source messages matched --includeMessages=".concat(includeMessages.join(", "), "."));
+                            }
+                        }
+                        if (requestedLocales.size > 0) {
+                            requestedLocales.forEach(function (locale) { return explicitRuntimeLocales.add(locale); });
+                            if (selectedTargets.size === 0 && includeMessages.length === 0) {
+                                targetKeys.forEach(function (key) { return promotedTargetKeys.add(key); });
+                                messageKeys.forEach(function (key) { return promotedMessageKeys.add(key); });
+                            }
+                        }
+                    }
+                    for (_e = 0, _f = Array.from(promotedMessageKeys); _e < _f.length; _e++) {
+                        messageKey = _f[_e];
+                        if (matchesPattern(messageKey, excludeMessages)) {
+                            promotedMessageKeys.delete(messageKey);
+                        }
+                    }
+                    if (selectedTargets.size === 0 && requestedLocales.size === 0 && includeMessages.length > 0) {
+                        for (_g = 0, _h = Array.from(promotedMessageKeys); _g < _h.length; _g++) {
+                            messageKey = _h[_g];
+                            message = messages[messageKey];
+                            if (!message)
+                                continue;
+                            Object.keys(message.translations || {}).forEach(function (locale) {
+                                return explicitRuntimeLocales.add(locale);
+                            });
+                            if (!options.excludeOverrides) {
+                                for (_j = 0, _k = message.overrides || []; _j < _k.length; _j++) {
+                                    override = _k[_j];
+                                    Object.keys(override.translations || {}).forEach(function (locale) {
+                                        return explicitRuntimeLocales.add(locale);
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    promotedLocaleKeys = new Set();
+                    localeFilterKeys = new Set();
+                    localeRestricted = requestedLocales.size > 0 || selectedTargets.size > 0;
+                    localeSeeds = requestedLocales.size > 0 ? requestedLocales : explicitRuntimeLocales;
+                    localeSeeds.forEach(function (locale) { return addLocaleWithAncestors(locale, promotedLocaleKeys); });
+                    (requestedLocales.size > 0 ? requestedLocales : new Set()).forEach(function (locale) {
+                        return addLocaleWithAncestors(locale, localeFilterKeys);
+                    });
+                    if (hasNoFilters && !localeRestricted && promotedLocaleKeys.size === 0) {
+                        localeKeys.forEach(function (key) { return promotedLocaleKeys.add(key); });
+                    }
+                    promotedSegmentKeys = new Set();
+                    promotedAttributeKeys = new Set();
+                    for (_l = 0, _m = Array.from(promotedMessageKeys); _l < _m.length; _l++) {
+                        messageKey = _m[_l];
+                        message = messages[messageKey];
+                        if (!message)
+                            continue;
+                        if (!options.excludeOverrides) {
+                            validateMessageOverrideKeys(messageKey, message);
+                            for (_o = 0, _p = message.overrides || []; _o < _p.length; _o++) {
+                                override = _p[_o];
+                                collectConditionDependencies(override.conditions, promotedSegmentKeys, promotedAttributeKeys);
+                                collectGroupSegmentKeys(override.segments, promotedSegmentKeys);
+                            }
+                        }
+                    }
+                    pendingSegments = Array.from(promotedSegmentKeys);
+                    for (index = 0; index < pendingSegments.length; index++) {
+                        segmentKey = pendingSegments[index];
+                        segment = segments[segmentKey];
+                        if (!segment)
+                            continue;
+                        beforeSize = promotedSegmentKeys.size;
+                        collectConditionDependencies(segment.conditions, promotedSegmentKeys, promotedAttributeKeys);
+                        if (promotedSegmentKeys.size > beforeSize) {
+                            pendingSegments.push.apply(pendingSegments, Array.from(promotedSegmentKeys).filter(function (key) { return !pendingSegments.includes(key); }));
+                        }
+                    }
+                    if (hasNoFilters) {
+                        segmentKeys.forEach(function (key) { return promotedSegmentKeys.add(key); });
+                        attributeKeys.forEach(function (key) { return promotedAttributeKeys.add(key); });
+                    }
+                    promotedTestKeys = testKeys.filter(function (key) {
+                        var test = tests[key];
+                        return (promotedMessageKeys.has(test.message) ||
+                            promotedSegmentKeys.has(test.segment) ||
+                            promotedTargetKeys.has(test.target) ||
+                            promotedLocaleKeys.has(test.locale));
+                    });
+                    plans = [];
+                    _q = 0, _r = Array.from(promotedLocaleKeys).sort();
+                    _2.label = 3;
+                case 3:
+                    if (!(_q < _r.length)) return [3 /*break*/, 6];
+                    key = _r[_q];
+                    if (!locales[key]) return [3 /*break*/, 5];
+                    return [4 /*yield*/, plan("locale", key, locales[key], function (entryKey) {
+                            return destinationDatasource.readLocale(entryKey);
+                        })];
+                case 4:
+                    _2.sent();
+                    _2.label = 5;
+                case 5:
+                    _q++;
+                    return [3 /*break*/, 3];
+                case 6:
+                    _s = 0, _t = Array.from(promotedAttributeKeys).sort();
+                    _2.label = 7;
+                case 7:
+                    if (!(_s < _t.length)) return [3 /*break*/, 10];
+                    key = _t[_s];
+                    if (!attributes[key]) return [3 /*break*/, 9];
+                    return [4 /*yield*/, plan("attribute", key, attributes[key], function (entryKey) {
+                            return destinationDatasource.readAttribute(entryKey);
+                        })];
+                case 8:
+                    _2.sent();
+                    _2.label = 9;
+                case 9:
+                    _s++;
+                    return [3 /*break*/, 7];
+                case 10:
+                    _u = 0, _v = Array.from(promotedSegmentKeys).sort();
+                    _2.label = 11;
+                case 11:
+                    if (!(_u < _v.length)) return [3 /*break*/, 14];
+                    key = _v[_u];
+                    if (!segments[key]) return [3 /*break*/, 13];
+                    return [4 /*yield*/, plan("segment", key, segments[key], function (entryKey) {
+                            return destinationDatasource.readSegment(entryKey);
+                        })];
+                case 12:
+                    _2.sent();
+                    _2.label = 13;
+                case 13:
+                    _u++;
+                    return [3 /*break*/, 11];
+                case 14:
+                    targetLocaleFilter = requestedLocales.size > 0 ? new Set(Array.from(requestedLocales)) : new Set();
+                    _w = 0, _x = Array.from(promotedTargetKeys).sort();
+                    _2.label = 15;
+                case 15:
+                    if (!(_w < _x.length)) return [3 /*break*/, 18];
+                    key = _x[_w];
+                    if (!targets[key]) return [3 /*break*/, 17];
+                    return [4 /*yield*/, plan("target", key, filterTargetForLocales(targets[key], targetLocaleFilter), function (entryKey) { return destinationDatasource.readTarget(entryKey); })];
+                case 16:
+                    _2.sent();
+                    _2.label = 17;
+                case 17:
+                    _w++;
+                    return [3 /*break*/, 15];
+                case 18:
+                    messageLocaleFilter = localeFilterKeys.size > 0 ? localeFilterKeys : new Set();
+                    _loop_3 = function (key) {
+                        var sourceMessage;
+                        return __generator(this, function (_3) {
+                            switch (_3.label) {
+                                case 0:
+                                    if (!messages[key]) return [3 /*break*/, 2];
+                                    sourceMessage = options.excludeOverrides
+                                        ? removeMessageOverrides(filterMessageForLocales(messages[key], messageLocaleFilter))
+                                        : filterMessageForLocales(messages[key], messageLocaleFilter);
+                                    return [4 /*yield*/, plan("message", key, sourceMessage, function (entryKey) { return destinationDatasource.readMessage(entryKey); }, function (destination, source, conflicts) {
+                                            return mergeMessage(key, destination, source, options.conflicts, conflicts);
+                                        })];
+                                case 1:
+                                    _3.sent();
+                                    _3.label = 2;
+                                case 2: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _y = 0, _z = Array.from(promotedMessageKeys).sort();
+                    _2.label = 19;
+                case 19:
+                    if (!(_y < _z.length)) return [3 /*break*/, 22];
+                    key = _z[_y];
+                    return [5 /*yield**/, _loop_3(key)];
+                case 20:
+                    _2.sent();
+                    _2.label = 21;
+                case 21:
+                    _y++;
+                    return [3 /*break*/, 19];
+                case 22:
+                    _0 = 0, _1 = promotedTestKeys.sort();
+                    _2.label = 23;
+                case 23:
+                    if (!(_0 < _1.length)) return [3 /*break*/, 26];
+                    key = _1[_0];
+                    test_1 = filterTestForLocales(tests[key], requestedLocales);
+                    if (!(!Array.isArray(test_1.assertions) || test_1.assertions.length > 0)) return [3 /*break*/, 25];
+                    return [4 /*yield*/, plan("test", key, test_1, function (entryKey) { return destinationDatasource.readTest(entryKey); })];
+                case 24:
+                    _2.sent();
+                    _2.label = 25;
+                case 25:
+                    _0++;
+                    return [3 /*break*/, 23];
+                case 26: return [2 /*return*/, plans];
+            }
+        });
+    });
+}
+function writePlan(destinationDatasource, plans) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _i, plans_1, plan;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _i = 0, plans_1 = plans;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < plans_1.length)) return [3 /*break*/, 14];
+                    plan = plans_1[_i];
+                    if (deepEqual(plan.destination, plan.merged)) {
+                        return [3 /*break*/, 13];
+                    }
+                    if (!(plan.type === "locale")) return [3 /*break*/, 3];
+                    return [4 /*yield*/, destinationDatasource.writeLocale(plan.key, plan.merged)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    if (!(plan.type === "attribute")) return [3 /*break*/, 5];
+                    return [4 /*yield*/, destinationDatasource.writeAttribute(plan.key, plan.merged)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5:
+                    if (!(plan.type === "segment")) return [3 /*break*/, 7];
+                    return [4 /*yield*/, destinationDatasource.writeSegment(plan.key, plan.merged)];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7:
+                    if (!(plan.type === "target")) return [3 /*break*/, 9];
+                    return [4 /*yield*/, destinationDatasource.writeTarget(plan.key, plan.merged)];
+                case 8:
+                    _a.sent();
+                    _a.label = 9;
+                case 9:
+                    if (!(plan.type === "message")) return [3 /*break*/, 11];
+                    return [4 /*yield*/, destinationDatasource.writeMessage(plan.key, plan.merged)];
+                case 10:
+                    _a.sent();
+                    _a.label = 11;
+                case 11:
+                    if (!(plan.type === "test")) return [3 /*break*/, 13];
+                    return [4 /*yield*/, destinationDatasource.writeTest(plan.key, plan.merged)];
+                case 12:
+                    _a.sent();
+                    _a.label = 13;
+                case 13:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 14: return [2 /*return*/];
+            }
+        });
+    });
+}
+function normalizeConflictPolicy(value) {
+    if (typeof value === "undefined" || value === false) {
+        return "source";
+    }
+    if (value === "source" || value === "destination" || value === "fail") {
+        return value;
+    }
+    throw new error_1.MessagevisorCLIError("Invalid --conflicts value \"".concat(String(value), "\". Use source, destination, or fail."));
+}
+function normalizeAuditFormat(value) {
+    if (typeof value === "undefined" || value === false || value === "false") {
+        return false;
+    }
+    if (value === true || value === "true") {
+        return "json";
+    }
+    if (value === "json" || value === "markdown") {
+        return value;
+    }
+    throw new error_1.MessagevisorCLIError("Invalid --audit value \"".concat(String(value), "\". Use json or markdown."));
+}
+function getTimestamp() {
+    var date = new Date();
+    var pad = function (value) { return (value < 10 ? "0".concat(value) : String(value)); };
+    return [
+        date.getUTCFullYear(),
+        pad(date.getUTCMonth() + 1),
+        pad(date.getUTCDate()),
+        "T",
+        pad(date.getUTCHours()),
+        pad(date.getUTCMinutes()),
+        pad(date.getUTCSeconds()),
+    ].join("");
+}
+function getPromotionAuditFilePath(projectConfig, result, format) {
+    return __awaiter(this, void 0, void 0, function () {
+        var extension, baseFileName, directoryPath, suffix, fileName, filePath;
+        return __generator(this, function (_a) {
+            extension = format === "markdown" ? "md" : "json";
+            baseFileName = "".concat(getTimestamp(), "-").concat(result.from, "-to-").concat(result.to);
+            directoryPath = path.join(projectConfig.stateDirectoryPath, "promotions");
+            suffix = 0;
+            while (true) {
+                fileName = "".concat(baseFileName).concat(suffix === 0 ? "" : "-".concat(suffix), ".").concat(extension);
+                filePath = path.join(directoryPath, fileName);
+                if (!fs.existsSync(filePath)) {
+                    return [2 /*return*/, filePath];
+                }
+                suffix++;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function getAuditPayload(result) {
+    return {
+        from: result.from,
+        to: result.to,
+        apply: result.apply,
+        filters: result.filters,
+        dependencies: result.dependencies,
+        files: result.files,
+        conflicts: result.conflicts.map(function (conflict) { return ({
+            type: conflict.type,
+            key: conflict.key,
+            path: conflict.path,
+            source: conflict.source,
+            destination: conflict.destination,
+        }); }),
+        duration: result.duration,
+    };
+}
+function stringifyMarkdownAudit(result) {
+    var lines = [
+        "# Messagevisor Promotion",
+        "",
+        "- From: ".concat(result.from),
+        "- To: ".concat(result.to),
+        "- Mode: ".concat(result.apply ? "apply" : "preview"),
+        "- Conflicts: ".concat(result.filters.conflicts),
+        "- Exclude overrides: ".concat(result.filters.excludeOverrides ? "true" : "false"),
+        "- Duration: ".concat((0, prettyDuration_1.prettyDuration)(result.duration)),
+        "",
+        "## Dependencies",
+        "",
+        "- Locales: ".concat(result.dependencies.locales),
+        "- Attributes: ".concat(result.dependencies.attributes),
+        "- Segments: ".concat(result.dependencies.segments),
+        "- Targets: ".concat(result.dependencies.targets),
+        "- Messages: ".concat(result.dependencies.messages),
+        "- Tests: ".concat(result.dependencies.tests),
+        "",
+        "## Files",
+        "",
+    ];
+    for (var _i = 0, _a = [
+        ["Created", result.files.created],
+        ["Updated", result.files.updated],
+        ["Unchanged", result.files.unchanged],
+    ]; _i < _a.length; _i++) {
+        var _b = _a[_i], label = _b[0], files = _b[1];
+        lines.push("### ".concat(label), "");
+        lines.push.apply(lines, (files.length > 0 ? files.map(function (filePath) { return "- ".concat(filePath); }) : ["- None"]));
+        lines.push("");
+    }
+    if (result.conflicts.length > 0) {
+        lines.push("## Conflicts", "");
+        lines.push.apply(lines, result.conflicts.map(function (conflict) { return "- ".concat(conflict.type, " ").concat(conflict.key, " at ").concat(conflict.path); }));
+        lines.push("");
+    }
+    return "".concat(lines.join("\n"), "\n");
+}
+function writePromotionAudit(projectConfig, result, format) {
+    return __awaiter(this, void 0, void 0, function () {
+        var filePath, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getPromotionAuditFilePath(projectConfig, result, format)];
+                case 1:
+                    filePath = _a.sent();
+                    return [4 /*yield*/, fs.promises.mkdir(path.dirname(filePath), { recursive: true })];
+                case 2:
+                    _a.sent();
+                    content = format === "markdown"
+                        ? stringifyMarkdownAudit(result)
+                        : "".concat(JSON.stringify(getAuditPayload(result), null, 2), "\n");
+                    return [4 /*yield*/, fs.promises.writeFile(filePath, content)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, path.relative(process.cwd(), filePath)];
+            }
+        });
+    });
+}
+function promoteProjectSets(projectConfig, datasource, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var startTime, conflictPolicy, auditFormat, sets, sourceDatasource, destinationDatasource, plans, conflicts, preview, suffix, created, updated, unchanged, result, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    startTime = Date.now();
+                    conflictPolicy = normalizeConflictPolicy(options.conflicts);
+                    auditFormat = normalizeAuditFormat(options.audit);
+                    if (!projectConfig.sets)
+                        throw new error_1.MessagevisorCLIError("Promotion is only available when `sets: true` is configured.");
+                    if (!options.from)
+                        throw new error_1.MessagevisorCLIError("Pass --from=<set>.");
+                    if (!options.to)
+                        throw new error_1.MessagevisorCLIError("Pass --to=<set>.");
+                    if (options.from === options.to)
+                        throw new error_1.MessagevisorCLIError("--from and --to must be different sets.");
+                    return [4 /*yield*/, datasource.listSets()];
+                case 1:
+                    sets = _b.sent();
+                    if (!sets.includes(options.from))
+                        throw new error_1.MessagevisorCLIError("Unknown source set \"".concat(options.from, "\". Available sets: ").concat(sets.join(", ") || "none", "."));
+                    if (!sets.includes(options.to))
+                        throw new error_1.MessagevisorCLIError("Unknown destination set \"".concat(options.to, "\". Available sets: ").concat(sets.join(", ") || "none", "."));
+                    assertAllowedPromotionFlow(projectConfig, options.from, options.to);
+                    sourceDatasource = datasource.forSet(options.from);
+                    destinationDatasource = datasource.forSet(options.to);
+                    return [4 /*yield*/, assertSetLintsClean(options.from, sourceDatasource)];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, assertSetLintsClean(options.to, destinationDatasource)];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, getPromotionPlan(sourceDatasource, destinationDatasource, {
+                            target: options.target || [],
+                            locale: options.locale || [],
+                            includeMessages: options.includeMessages || [],
+                            excludeMessages: options.excludeMessages || [],
+                            excludeOverrides: options.excludeOverrides === true,
+                            allowEmpty: options.allowEmpty === true,
+                            conflicts: conflictPolicy,
+                        })];
+                case 4:
+                    plans = _b.sent();
+                    conflicts = plans.flatMap(function (plan) { return plan.conflicts; });
+                    if (conflictPolicy === "fail" && conflicts.length > 0) {
+                        preview = conflicts
+                            .slice(0, 5)
+                            .map(function (conflict) { return "".concat(conflict.type, " \"").concat(conflict.key, "\" at ").concat(conflict.path); })
+                            .join("\n");
+                        suffix = conflicts.length > 5 ? "\n...and ".concat(conflicts.length - 5, " more") : "";
+                        throw new error_1.MessagevisorCLIError("Promotion has ".concat(conflicts.length, " conflict(s) and --conflicts=fail was used.\n").concat(preview).concat(suffix));
+                    }
+                    if (!(options.apply === true)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, writePlan(destinationDatasource, plans)];
+                case 5:
+                    _b.sent();
+                    _b.label = 6;
+                case 6:
+                    created = plans
+                        .filter(function (plan) { return !plan.destination; })
+                        .map(function (plan) {
+                        return path.relative(process.cwd(), getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key));
+                    });
+                    updated = plans
+                        .filter(function (plan) { return plan.destination && !deepEqual(plan.destination, plan.merged); })
+                        .map(function (plan) {
+                        return path.relative(process.cwd(), getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key));
+                    });
+                    unchanged = plans
+                        .filter(function (plan) { return plan.destination && deepEqual(plan.destination, plan.merged); })
+                        .map(function (plan) {
+                        return path.relative(process.cwd(), getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key));
+                    });
+                    result = {
+                        from: options.from,
+                        to: options.to,
+                        apply: options.apply === true,
+                        duration: Date.now() - startTime,
+                        filters: {
+                            targets: toArray(options.target),
+                            locales: toArray(options.locale),
+                            includeMessages: toArray(options.includeMessages),
+                            excludeMessages: toArray(options.excludeMessages),
+                            excludeOverrides: options.excludeOverrides === true,
+                            conflicts: conflictPolicy,
+                        },
+                        dependencies: {
+                            locales: plans.filter(function (plan) { return plan.type === "locale"; }).length,
+                            attributes: plans.filter(function (plan) { return plan.type === "attribute"; }).length,
+                            segments: plans.filter(function (plan) { return plan.type === "segment"; }).length,
+                            targets: plans.filter(function (plan) { return plan.type === "target"; }).length,
+                            messages: plans.filter(function (plan) { return plan.type === "message"; }).length,
+                            tests: plans.filter(function (plan) { return plan.type === "test"; }).length,
+                        },
+                        files: { created: created, updated: updated, unchanged: unchanged },
+                        conflicts: conflicts,
+                    };
+                    if (!(result.apply && auditFormat)) return [3 /*break*/, 8];
+                    _a = result;
+                    return [4 /*yield*/, writePromotionAudit(projectConfig, result, auditFormat)];
+                case 7:
+                    _a.auditFilePath = _b.sent();
+                    _b.label = 8;
+                case 8: return [2 /*return*/, result];
+            }
+        });
+    });
+}
+function printPromoteResult(result, options) {
+    if (options === void 0) { options = {}; }
+    console.log("");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Promoting Messagevisor set translations");
+    console.log("  From: ".concat(result.from));
+    console.log("  To:   ".concat(result.to));
+    console.log("  Mode: ".concat(result.apply ? "apply" : "preview"));
+    if (result.filters.targets.length > 0)
+        console.log("  Targets: ".concat(result.filters.targets.join(", ")));
+    if (result.filters.locales.length > 0)
+        console.log("  Locales: ".concat(result.filters.locales.join(", ")));
+    if (result.filters.includeMessages.length > 0)
+        console.log("  Include messages: ".concat(result.filters.includeMessages.join(", ")));
+    if (result.filters.excludeMessages.length > 0)
+        console.log("  Exclude messages: ".concat(result.filters.excludeMessages.join(", ")));
+    console.log("  Conflict policy: ".concat(result.filters.conflicts));
+    console.log("  Overrides: ".concat(result.filters.excludeOverrides ? "excluded; existing destination overrides are preserved" : "included"));
+    console.log("");
+    console.log("  Dependencies: ".concat(result.dependencies.locales, " locales, ").concat(result.dependencies.attributes, " attributes, ").concat(result.dependencies.segments, " segments, ").concat(result.dependencies.targets, " targets, ").concat(result.dependencies.messages, " messages, ").concat(result.dependencies.tests, " tests"));
+    console.log("  Created:   ".concat(result.files.created.length));
+    console.log("  Updated:   ".concat(result.files.updated.length));
+    console.log("  Unchanged: ".concat(result.files.unchanged.length));
+    console.log("  Conflicts: ".concat(result.conflicts.length));
+    console.log("");
+    printFileGroup("Created", result.files.created, 32);
+    printFileGroup("Updated", result.files.updated, 33);
+    if (options.showUnchanged === true) {
+        printFileGroup("Unchanged", result.files.unchanged, 2);
+    }
+    printConflictPreview(result.conflicts);
+    if (result.auditFilePath) {
+        console.log("  Audit: ".concat((0, cliFormat_1.colorize)(result.auditFilePath, 36)));
+        console.log("");
+    }
+    console.log(cliFormat_1.CLI_FORMAT_GREEN, result.apply ? "Promotion applied" : "Promotion preview complete");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Time: ".concat((0, prettyDuration_1.prettyDuration)(result.duration)));
+}
+function printFileGroup(label, files, color) {
+    if (files.length === 0) {
+        return;
+    }
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, label);
+    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+        var filePath = files_1[_i];
+        console.log("  ".concat((0, cliFormat_1.colorize)(filePath, color)));
+    }
+    console.log("");
+}
+function printConflictPreview(conflicts) {
+    if (conflicts.length === 0) {
+        return;
+    }
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Conflicts");
+    for (var _i = 0, _a = conflicts.slice(0, 10); _i < _a.length; _i++) {
+        var conflict = _a[_i];
+        console.log("  ".concat((0, cliFormat_1.colorize)(conflict.type, 33), " ").concat(conflict.key, " ").concat((0, cliFormat_1.colorize)(conflict.path, 2)));
+    }
+    if (conflicts.length > 10) {
+        console.log("  ".concat((0, cliFormat_1.colorize)("...and ".concat(conflicts.length - 10, " more"), 2)));
+    }
+    console.log("");
+}
+exports.promotePlugin = {
+    command: "promote",
+    handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var result, error_2;
+        var projectConfig = _b.projectConfig, datasource = _b.datasource, parsed = _b.parsed;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, promoteProjectSets(projectConfig, datasource, {
+                            from: parsed.from,
+                            to: parsed.to,
+                            target: parsed.target,
+                            locale: parsed.locale,
+                            includeMessages: parsed.includeMessages,
+                            excludeMessages: parsed.excludeMessages,
+                            excludeOverrides: parsed.excludeOverrides,
+                            conflicts: parsed.conflicts,
+                            allowEmpty: parsed.allowEmpty,
+                            apply: parsed.apply === true || parsed.apply === "true",
+                            audit: parsed.audit,
+                        })];
+                case 1:
+                    result = _c.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_2 = _c.sent();
+                    if ((0, error_1.printMessagevisorCLIError)(error_2)) {
+                        return [2 /*return*/, false];
+                    }
+                    throw error_2;
+                case 3:
+                    printPromoteResult(result, {
+                        showUnchanged: parsed.showUnchanged === true || parsed.showUnchanged === "true",
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); },
+    examples: [
+        {
+            command: "promote --from=dev --to=staging",
+            description: "preview all translations that can be promoted from one set to another",
+        },
+        {
+            command: "promote --from=dev --to=staging --target=web",
+            description: "preview translations affecting a target",
+        },
+        {
+            command: "promote --from=dev --to=staging --excludeOverrides",
+            description: "preview messages without copying overrides",
+        },
+        {
+            command: "promote --from=dev --to=staging --conflicts=fail",
+            description: "fail instead of overwriting conflicting destination fields",
+        },
+        {
+            command: "promote --from=dev --to=staging --apply",
+            description: "apply a promotion and write destination files",
+        },
+        {
+            command: "promote --from=dev --to=staging --apply --audit=markdown",
+            description: "write a promotion audit file",
+        },
+        {
+            command: "promote --from=dev --to=staging --showUnchanged",
+            description: "preview a promotion and include unchanged entries",
+        },
+    ],
+};
+//# sourceMappingURL=index.js.map