@messagevisor/core 0.0.1 → 0.1.0

package/lib/importer/index.js

@@ -0,0 +1,1092 @@
+"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.importPlugin = void 0;
+exports.importProject = importProject;
+exports.importProjectSets = importProjectSets;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+var error_1 = require("../error");
+var sets_1 = require("../sets");
+var cliFormat_1 = require("../tester/cliFormat");
+var prettyDuration_1 = require("../tester/prettyDuration");
+function toArray(value) {
+    if (typeof value === "undefined")
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function withoutKey(entity) {
+    var _key = entity.key, rest = __rest(entity, ["key"]);
+    return rest;
+}
+function cloneMessage(message) {
+    return JSON.parse(JSON.stringify(withoutKey(message)));
+}
+function parseCsv(content, delimiter) {
+    if (delimiter === void 0) { delimiter = ","; }
+    var source = content.charCodeAt(0) === 0xfeff ? content.slice(1) : content;
+    var rows = [];
+    var row = [];
+    var cell = "";
+    var inQuotes = false;
+    var quoteClosed = false;
+    for (var index = 0; index < source.length; index++) {
+        var char = source[index];
+        var next = source[index + 1];
+        if (inQuotes) {
+            if (char === '"' && next === '"') {
+                cell += '"';
+                index++;
+            }
+            else if (char === '"') {
+                inQuotes = false;
+                quoteClosed = true;
+            }
+            else if (char === "\r") {
+                if (next === "\n")
+                    index++;
+                cell += "\n";
+            }
+            else {
+                cell += char;
+            }
+            continue;
+        }
+        if (quoteClosed) {
+            if (char === delimiter) {
+                row.push(cell);
+                cell = "";
+                quoteClosed = false;
+            }
+            else if (char === "\n") {
+                row.push(cell);
+                rows.push(row);
+                row = [];
+                cell = "";
+                quoteClosed = false;
+            }
+            else if (char === "\r") {
+                if (next === "\n")
+                    index++;
+                row.push(cell);
+                rows.push(row);
+                row = [];
+                cell = "";
+                quoteClosed = false;
+            }
+            else {
+                throw new error_1.MessagevisorCLIError("Invalid CSV: unexpected character after closing quote.");
+            }
+        }
+        else if (char === '"') {
+            if (cell.length > 0) {
+                throw new error_1.MessagevisorCLIError("Invalid CSV: unexpected quote in unquoted field.");
+            }
+            inQuotes = true;
+        }
+        else if (char === delimiter) {
+            row.push(cell);
+            cell = "";
+        }
+        else if (char === "\n") {
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = "";
+        }
+        else if (char === "\r") {
+            if (next === "\n")
+                index++;
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = "";
+        }
+        else {
+            cell += char;
+        }
+    }
+    if (inQuotes) {
+        throw new error_1.MessagevisorCLIError("Invalid CSV: unterminated quoted field.");
+    }
+    if (cell.length > 0 || row.length > 0 || quoteClosed) {
+        row.push(cell);
+        rows.push(row);
+    }
+    var _a = rows[0], headers = _a === void 0 ? [] : _a, dataRows = rows.slice(1);
+    return {
+        headers: headers,
+        rows: dataRows
+            .map(function (dataRow, index) { return ({
+            dataRow: dataRow,
+            rowNumber: index + 2,
+        }); })
+            .filter(function (_a) {
+            var dataRow = _a.dataRow;
+            return dataRow.some(function (value) { return value !== ""; });
+        })
+            .map(function (_a) {
+            var dataRow = _a.dataRow, rowNumber = _a.rowNumber;
+            if (dataRow.length > headers.length) {
+                throw new error_1.MessagevisorCLIError("Invalid CSV: row ".concat(rowNumber, " has ").concat(dataRow.length, " cells but only ").concat(headers.length, " headers."));
+            }
+            return Object.fromEntries(headers.map(function (header, index) { return [header, dataRow[index] || ""]; }));
+        }),
+    };
+}
+function assertOptions(options) {
+    if (typeof options.delimiter !== "undefined" && options.delimiter.length !== 1) {
+        throw new error_1.MessagevisorCLIError("--delimiter must be a single character.");
+    }
+    if (options.fromJson && typeof options.delimiter !== "undefined") {
+        throw new error_1.MessagevisorCLIError("--delimiter can only be used with CSV imports.");
+    }
+    if (options.fromJson && typeof options.bom !== "undefined") {
+        throw new error_1.MessagevisorCLIError("--bom can only be used with CSV imports.");
+    }
+}
+function isHttpUrl(input) {
+    return /^https?:\/\//i.test(input);
+}
+function getInputFilePath(projectConfig, options, parsed) {
+    var _a;
+    var input = options.input || ((_a = parsed === null || parsed === void 0 ? void 0 : parsed._) === null || _a === void 0 ? void 0 : _a[1]);
+    if (!input) {
+        throw new error_1.MessagevisorCLIError(options.fromJson
+            ? "Pass a JSON file path or URL: messagevisor import <jsonFilePathOrUrl> --from-json --locale=<locale>."
+            : "Pass a CSV file path: messagevisor import <csvFilePath>.");
+    }
+    if (options.fromJson && isHttpUrl(input)) {
+        return input;
+    }
+    var projectRootDirectoryPath = path.dirname(projectConfig.exportsDirectoryPath);
+    return path.isAbsolute(input) ? input : path.join(projectRootDirectoryPath, input);
+}
+function readAll(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 resolveLocaleChain(localeKey, locales) {
+    var _a;
+    var chain = [];
+    var seen = new Set();
+    var currentKey = localeKey;
+    while (currentKey && !seen.has(currentKey)) {
+        seen.add(currentKey);
+        chain.unshift(currentKey);
+        currentKey = (_a = locales[currentKey]) === null || _a === void 0 ? void 0 : _a.inheritTranslationsFrom;
+    }
+    return chain;
+}
+function resolveTranslation(translations, localeKey, locales) {
+    if (typeof (translations === null || translations === void 0 ? void 0 : translations[localeKey]) !== "undefined") {
+        return translations[localeKey];
+    }
+    for (var _i = 0, _a = resolveLocaleChain(localeKey, locales).reverse(); _i < _a.length; _i++) {
+        var candidate = _a[_i];
+        if (translations && typeof translations[candidate] !== "undefined") {
+            return translations[candidate];
+        }
+    }
+    return undefined;
+}
+function resolveInheritedTranslationValue(translations, localeKey, locales) {
+    var _a, _b;
+    var currentKey = (_a = locales[localeKey]) === null || _a === void 0 ? void 0 : _a.inheritTranslationsFrom;
+    while (currentKey) {
+        if (translations && typeof translations[currentKey] !== "undefined") {
+            return translations[currentKey];
+        }
+        currentKey = (_b = locales[currentKey]) === null || _b === void 0 ? void 0 : _b.inheritTranslationsFrom;
+    }
+}
+function getLocaleInheritanceDepth(localeKey, locales) {
+    var _a, _b;
+    var depth = 0;
+    var seen = new Set();
+    var currentKey = (_a = locales[localeKey]) === null || _a === void 0 ? void 0 : _a.inheritTranslationsFrom;
+    while (currentKey && !seen.has(currentKey)) {
+        seen.add(currentKey);
+        depth++;
+        currentKey = (_b = locales[currentKey]) === null || _b === void 0 ? void 0 : _b.inheritTranslationsFrom;
+    }
+    return depth;
+}
+function splitMessageKey(projectConfig, key) {
+    var separator = projectConfig.exportOverrideKeySeparator;
+    var separatorIndex = key.lastIndexOf(separator);
+    if (separatorIndex === -1) {
+        return { messageKey: key };
+    }
+    return {
+        messageKey: key.slice(0, separatorIndex),
+        overrideKey: key.slice(separatorIndex + separator.length),
+    };
+}
+function getLocaleHeaders(headers, localeKeys) {
+    var reservedHeaders = new Set(["set", "messageKey", "messageDescription"]);
+    return headers.filter(function (header) {
+        return !reservedHeaders.has(header) && !header.endsWith("Status") && localeKeys.includes(header);
+    });
+}
+function getUnknownTranslationHeaders(headers, localeKeys) {
+    var reservedHeaders = new Set(["set", "messageKey", "messageDescription"]);
+    return headers.filter(function (header) {
+        return !reservedHeaders.has(header) && !header.endsWith("Status") && !localeKeys.includes(header);
+    });
+}
+function assertKnownLocales(requestedLocales, localeKeys) {
+    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+        var locale = requestedLocales_1[_i];
+        if (!localeKeys.includes(locale)) {
+            throw new error_1.MessagevisorCLIError("Unknown locale \"".concat(locale, "\". Available locales: ").concat(localeKeys.join(", ") || "none", "."));
+        }
+    }
+}
+function getSelectedLocaleHeaders(headers, localeKeys, requestedLocales) {
+    var localeHeaders = getLocaleHeaders(headers, localeKeys);
+    if (requestedLocales.length === 0) {
+        return localeHeaders;
+    }
+    assertKnownLocales(requestedLocales, localeKeys);
+    return localeHeaders.filter(function (locale) { return requestedLocales.includes(locale); });
+}
+function toImportRows(projectConfig, csv, localeHeaders) {
+    if (!csv.headers.includes("messageKey")) {
+        throw new error_1.MessagevisorCLIError('CSV must include a "messageKey" column.');
+    }
+    return csv.rows.map(function (row, index) {
+        var _a = splitMessageKey(projectConfig, row.messageKey || ""), messageKey = _a.messageKey, overrideKey = _a.overrideKey;
+        return {
+            rowNumber: index + 2,
+            set: row.set || undefined,
+            messageKey: messageKey,
+            overrideKey: overrideKey,
+            values: Object.fromEntries(localeHeaders.map(function (locale) { return [locale, row[locale] || ""]; })),
+        };
+    });
+}
+function addWarning(warnings, message) {
+    warnings.push(message);
+}
+function getOrCreatePlan(plansByKey, set, messageKey, original) {
+    var planKey = "".concat(set || "", ":").concat(messageKey);
+    var existing = plansByKey.get(planKey);
+    if (existing) {
+        return existing;
+    }
+    var plan = {
+        set: set,
+        key: messageKey,
+        original: original,
+        updated: original ? cloneMessage(original) : { description: "", translations: {} },
+        createdMessage: !original,
+        createdOverrides: [],
+        changedLocales: [],
+        changedOverrideLocales: [],
+        prunedLocales: [],
+        prunedOverrideLocales: [],
+    };
+    plansByKey.set(planKey, plan);
+    return plan;
+}
+function shouldApplyTranslation(translations, locale, value, locales) {
+    if (value === "") {
+        return false;
+    }
+    if (translations && typeof translations[locale] !== "undefined") {
+        return translations[locale] !== value;
+    }
+    return resolveTranslation(translations, locale, locales) !== value;
+}
+function getImportValueEntries(values, locales) {
+    return Object.entries(values).sort(function (_a, _b) {
+        var leftLocale = _a[0];
+        var rightLocale = _b[0];
+        return getLocaleInheritanceDepth(leftLocale, locales) -
+            getLocaleInheritanceDepth(rightLocale, locales);
+    });
+}
+function getOrCreateOverride(message, overrideKey, createMissing) {
+    var overrides = message.overrides || [];
+    var existing = overrides.find(function (override) { return override.key === overrideKey; });
+    if (existing) {
+        return { override: existing, created: false };
+    }
+    if (!createMissing) {
+        return { created: false };
+    }
+    var created = {
+        key: overrideKey,
+        segments: "*",
+        translations: {},
+    };
+    message.overrides = __spreadArray(__spreadArray([], overrides, true), [created], false);
+    return { override: created, created: true };
+}
+function collectImportPlansForDatasource(datasource, rows, options, set, warnings) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, localeKeys, messageKeys, locales, messages, plansByKey, skippedRows, skippedCells, prunedTranslations, sortedRows, _loop_1, _i, sortedRows_1, row;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, Promise.all([
+                        datasource.listLocales(),
+                        datasource.listMessages(),
+                    ])];
+                case 1:
+                    _a = _d.sent(), localeKeys = _a[0], messageKeys = _a[1];
+                    return [4 /*yield*/, readAll(localeKeys, function (key) { return datasource.readLocale(key); })];
+                case 2:
+                    locales = _d.sent();
+                    return [4 /*yield*/, readAll(messageKeys, function (key) { return datasource.readMessage(key); })];
+                case 3:
+                    messages = _d.sent();
+                    plansByKey = new Map();
+                    skippedRows = 0;
+                    skippedCells = 0;
+                    prunedTranslations = 0;
+                    sortedRows = __spreadArray([], rows, true).sort(function (a, b) { return Number(Boolean(a.overrideKey)) - Number(Boolean(b.overrideKey)); });
+                    _loop_1 = function (row) {
+                        var _e, _f;
+                        if (!row.messageKey) {
+                            skippedRows++;
+                            addWarning(warnings, "Row ".concat(row.rowNumber, ": missing messageKey."));
+                            return "continue";
+                        }
+                        var planKey = "".concat(set || "", ":").concat(row.messageKey);
+                        var existingPlan = plansByKey.get(planKey);
+                        var message = messages[row.messageKey];
+                        if (!message && !options.createMissing) {
+                            skippedRows++;
+                            addWarning(warnings, "Row ".concat(row.rowNumber, ": unknown message \"").concat(row.messageKey, "\"."));
+                            return "continue";
+                        }
+                        if (row.overrideKey && !message && !existingPlan && options.createMissing) {
+                            skippedRows++;
+                            addWarning(warnings, "Row ".concat(row.rowNumber, ": cannot create override \"").concat(row.overrideKey, "\" because message \"").concat(row.messageKey, "\" does not exist or is not created by another row."));
+                            return "continue";
+                        }
+                        var plan = getOrCreatePlan(plansByKey, set, row.messageKey, message);
+                        if (row.overrideKey) {
+                            var _g = getOrCreateOverride(plan.updated, row.overrideKey, options.createMissing), override = _g.override, created = _g.created;
+                            if (!override) {
+                                skippedRows++;
+                                addWarning(warnings, "Row ".concat(row.rowNumber, ": unknown override \"").concat(row.overrideKey, "\" in message \"").concat(row.messageKey, "\"."));
+                                return "continue";
+                            }
+                            var changed = false;
+                            for (var _h = 0, _j = getImportValueEntries(row.values, locales); _h < _j.length; _h++) {
+                                var _k = _j[_h], locale = _k[0], value = _k[1];
+                                if (!localeKeys.includes(locale)) {
+                                    skippedCells++;
+                                    addWarning(warnings, "Row ".concat(row.rowNumber, ": unknown locale \"").concat(locale, "\"."));
+                                    continue;
+                                }
+                                var inherited = options.prune
+                                    ? resolveInheritedTranslationValue(override.translations, locale, locales)
+                                    : undefined;
+                                if (value !== "" && typeof inherited !== "undefined" && inherited === value) {
+                                    prunedTranslations++;
+                                    if (typeof ((_b = override.translations) === null || _b === void 0 ? void 0 : _b[locale]) !== "undefined") {
+                                        delete override.translations[locale];
+                                        plan.prunedOverrideLocales.push({ overrideKey: row.overrideKey, locale: locale });
+                                        changed = true;
+                                    }
+                                    continue;
+                                }
+                                if (!shouldApplyTranslation(override.translations, locale, value, locales)) {
+                                    skippedCells++;
+                                    continue;
+                                }
+                                override.translations = __assign(__assign({}, override.translations), (_e = {}, _e[locale] = value, _e));
+                                plan.changedOverrideLocales.push({ overrideKey: row.overrideKey, locale: locale });
+                                changed = true;
+                            }
+                            if (created && changed) {
+                                plan.createdOverrides.push(row.overrideKey);
+                            }
+                            if (created && !changed) {
+                                plan.updated.overrides = (plan.updated.overrides || []).filter(function (overrideEntry) { return overrideEntry.key !== row.overrideKey; });
+                            }
+                            return "continue";
+                        }
+                        for (var _l = 0, _m = getImportValueEntries(row.values, locales); _l < _m.length; _l++) {
+                            var _o = _m[_l], locale = _o[0], value = _o[1];
+                            if (!localeKeys.includes(locale)) {
+                                skippedCells++;
+                                addWarning(warnings, "Row ".concat(row.rowNumber, ": unknown locale \"").concat(locale, "\"."));
+                                continue;
+                            }
+                            var inherited = options.prune
+                                ? resolveInheritedTranslationValue(plan.updated.translations, locale, locales)
+                                : undefined;
+                            if (value !== "" && typeof inherited !== "undefined" && inherited === value) {
+                                prunedTranslations++;
+                                if (typeof ((_c = plan.updated.translations) === null || _c === void 0 ? void 0 : _c[locale]) !== "undefined") {
+                                    delete plan.updated.translations[locale];
+                                    plan.prunedLocales.push(locale);
+                                }
+                                continue;
+                            }
+                            if (!shouldApplyTranslation(plan.updated.translations, locale, value, locales)) {
+                                skippedCells++;
+                                continue;
+                            }
+                            plan.updated.translations = __assign(__assign({}, plan.updated.translations), (_f = {}, _f[locale] = value, _f));
+                            plan.changedLocales.push(locale);
+                        }
+                    };
+                    for (_i = 0, sortedRows_1 = sortedRows; _i < sortedRows_1.length; _i++) {
+                        row = sortedRows_1[_i];
+                        _loop_1(row);
+                    }
+                    return [2 /*return*/, {
+                            plans: Array.from(plansByKey.values()).filter(function (plan) {
+                                return plan.changedLocales.length > 0 ||
+                                    plan.changedOverrideLocales.length > 0 ||
+                                    plan.createdOverrides.length > 0 ||
+                                    plan.prunedLocales.length > 0 ||
+                                    plan.prunedOverrideLocales.length > 0;
+                            }),
+                            skippedRows: skippedRows,
+                            skippedCells: skippedCells,
+                            prunedTranslations: prunedTranslations,
+                        }];
+            }
+        });
+    });
+}
+function deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function writePlans(datasource, 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*/, 4];
+                    plan = plans_1[_i];
+                    if (plan.original && deepEqual(withoutKey(plan.original), plan.updated)) {
+                        return [3 /*break*/, 3];
+                    }
+                    return [4 /*yield*/, datasource.writeMessage(plan.key, plan.updated)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function createResult(inputFilePath, apply, startTime, rows, plans, skippedRows, skippedCells, prunedTranslations, warnings) {
+    var changedOverrideKeys = new Set(plans.flatMap(function (plan) {
+        return __spreadArray(__spreadArray([], plan.changedOverrideLocales, true), plan.prunedOverrideLocales, true).map(function (entry) { return "".concat(plan.set || "", ":").concat(plan.key, ":").concat(entry.overrideKey); });
+    }));
+    var changedMessagePlans = plans.filter(function (plan) { return plan.changedLocales.length > 0 || plan.prunedLocales.length > 0; });
+    return {
+        inputFilePath: inputFilePath,
+        apply: apply,
+        duration: Date.now() - startTime,
+        plans: plans,
+        warnings: warnings,
+        summary: {
+            rows: rows,
+            changedMessages: changedMessagePlans.length,
+            changedOverrides: changedOverrideKeys.size,
+            createdMessages: plans.filter(function (plan) { return plan.createdMessage; }).length,
+            createdOverrides: plans.reduce(function (sum, plan) { return sum + plan.createdOverrides.length; }, 0),
+            changedTranslations: plans.reduce(function (sum, plan) { return sum + plan.changedLocales.length; }, 0) +
+                plans.reduce(function (sum, plan) { return sum + plan.changedOverrideLocales.length; }, 0),
+            prunedTranslations: prunedTranslations,
+            skippedRows: skippedRows,
+            skippedCells: skippedCells,
+            warnings: warnings.length,
+            sets: Array.from(new Set(plans.map(function (plan) { return plan.set; }).filter(function (entry) { return Boolean(entry); }))),
+        },
+    };
+}
+function readCsv(inputFilePath, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!fs.existsSync(inputFilePath)) {
+                        throw new error_1.MessagevisorCLIError("CSV file does not exist: ".concat(inputFilePath));
+                    }
+                    _a = parseCsv;
+                    return [4 /*yield*/, fs.promises.readFile(inputFilePath, "utf8")];
+                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), options.delimiter || ","])];
+            }
+        });
+    });
+}
+function readJsonText(inputFilePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isHttpUrl(inputFilePath)) return [3 /*break*/, 5];
+                    response = void 0;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(inputFilePath)];
+                case 2:
+                    response = _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_2 = _a.sent();
+                    throw new error_1.MessagevisorCLIError("Unable to fetch JSON from ".concat(inputFilePath, "."));
+                case 4:
+                    if (!response.ok) {
+                        throw new error_1.MessagevisorCLIError("Unable to fetch JSON from ".concat(inputFilePath, ": ").concat(response.status, " ").concat(response.statusText).trim());
+                    }
+                    return [2 /*return*/, response.text()];
+                case 5:
+                    if (!fs.existsSync(inputFilePath)) {
+                        throw new error_1.MessagevisorCLIError("JSON file does not exist: ".concat(inputFilePath));
+                    }
+                    return [2 /*return*/, fs.promises.readFile(inputFilePath, "utf8")];
+            }
+        });
+    });
+}
+function parseJson(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new error_1.MessagevisorCLIError("Invalid JSON: unable to parse input.");
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function selectJsonPath(content, jsonPath) {
+    if (typeof jsonPath === "undefined") {
+        return content;
+    }
+    if (jsonPath.trim() === "") {
+        throw new error_1.MessagevisorCLIError("--json-path cannot be empty.");
+    }
+    var current = content;
+    for (var _i = 0, _a = jsonPath.split("."); _i < _a.length; _i++) {
+        var segment = _a[_i];
+        if (!segment) {
+            throw new error_1.MessagevisorCLIError("Invalid JSON path \"".concat(jsonPath, "\"."));
+        }
+        if (!isPlainObject(current) || !(segment in current)) {
+            throw new error_1.MessagevisorCLIError("JSON path \"".concat(jsonPath, "\" was not found."));
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function jsonToImportRows(projectConfig, content, locale, jsonPath) {
+    var selected = selectJsonPath(content, jsonPath);
+    if (!isPlainObject(selected)) {
+        throw new error_1.MessagevisorCLIError(jsonPath
+            ? "JSON path \"".concat(jsonPath, "\" must resolve to a flat object.")
+            : "JSON import input must be a flat object.");
+    }
+    return Object.entries(selected).map(function (_a, index) {
+        var _b;
+        var key = _a[0], value = _a[1];
+        if (typeof value !== "string") {
+            throw new error_1.MessagevisorCLIError("JSON translation value for \"".concat(key, "\" must be a string."));
+        }
+        var _c = splitMessageKey(projectConfig, key), messageKey = _c.messageKey, overrideKey = _c.overrideKey;
+        return {
+            rowNumber: index + 1,
+            messageKey: messageKey,
+            overrideKey: overrideKey,
+            values: (_b = {},
+                _b[locale] = value,
+                _b),
+        };
+    });
+}
+function getJsonImportLocale(options) {
+    var requestedLocales = toArray(options.locale);
+    if (requestedLocales.length !== 1) {
+        throw new error_1.MessagevisorCLIError("--from-json requires exactly one --locale=<locale>.");
+    }
+    return requestedLocales[0];
+}
+function readJsonImportInput(projectConfig, inputFilePath, locale, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var content, _a, rows;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = parseJson;
+                    return [4 /*yield*/, readJsonText(inputFilePath)];
+                case 1:
+                    content = _a.apply(void 0, [_b.sent()]);
+                    rows = jsonToImportRows(projectConfig, content, locale, options.jsonPath);
+                    return [2 /*return*/, {
+                            inputFilePath: inputFilePath,
+                            rows: rows,
+                            warnings: [],
+                            rowCount: rows.length,
+                        }];
+            }
+        });
+    });
+}
+function readCsvImportInput(projectConfig, datasource, inputFilePath, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var csv, localeKeys, requestedLocales, localeHeaders, unknownHeaders, warnings, rows;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, readCsv(inputFilePath, options)];
+                case 1:
+                    csv = _a.sent();
+                    if (csv.headers.includes("set") && hasNonEmptySetValues(csv)) {
+                        throw new error_1.MessagevisorCLIError('CSV "set" column can only contain values when `sets: true` is configured.');
+                    }
+                    return [4 /*yield*/, datasource.listLocales()];
+                case 2:
+                    localeKeys = _a.sent();
+                    requestedLocales = toArray(options.locale);
+                    localeHeaders = getSelectedLocaleHeaders(csv.headers, localeKeys, requestedLocales);
+                    unknownHeaders = getUnknownTranslationHeaders(csv.headers, localeKeys);
+                    warnings = unknownHeaders.map(function (header) { return "Ignoring unknown CSV column \"".concat(header, "\"."); });
+                    rows = toImportRows(projectConfig, csv, localeHeaders);
+                    return [2 /*return*/, {
+                            inputFilePath: inputFilePath,
+                            rows: rows,
+                            warnings: warnings,
+                            rowCount: rows.length,
+                        }];
+            }
+        });
+    });
+}
+function getAllLocaleKeysBySet(executions) {
+    var _this = this;
+    return Promise.all(executions.map(function (execution) { return __awaiter(_this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = {
+                        set: execution.set
+                    };
+                    return [4 /*yield*/, execution.datasource.listLocales()];
+                case 1: return [2 /*return*/, (_a.locales = _b.sent(),
+                        _a)];
+            }
+        });
+    }); }));
+}
+function hasNonEmptySetValues(csv) {
+    return csv.rows.some(function (row) { return row.set && row.set.trim() !== ""; });
+}
+function importProject(projectConfig_1, datasource_1) {
+    return __awaiter(this, arguments, void 0, function (projectConfig, datasource, options, parsed) {
+        var startTime, inputFilePath, input, _a, collected;
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    startTime = Date.now();
+                    assertOptions(options);
+                    if (projectConfig.sets) {
+                        return [2 /*return*/, importProjectSets(projectConfig, datasource, options, parsed)];
+                    }
+                    if (toArray(options.set).length > 0) {
+                        throw new error_1.MessagevisorCLIError("--set can only be used when `sets: true` is configured.");
+                    }
+                    inputFilePath = getInputFilePath(projectConfig, options, parsed);
+                    if (!options.fromJson) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var locale, localeKeys;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        locale = getJsonImportLocale(options);
+                                        return [4 /*yield*/, datasource.listLocales()];
+                                    case 1:
+                                        localeKeys = _a.sent();
+                                        assertKnownLocales([locale], localeKeys);
+                                        return [2 /*return*/, readJsonImportInput(projectConfig, inputFilePath, locale, options)];
+                                }
+                            });
+                        }); })()];
+                case 1:
+                    _a = _b.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, readCsvImportInput(projectConfig, datasource, inputFilePath, options)];
+                case 3:
+                    _a = _b.sent();
+                    _b.label = 4;
+                case 4:
+                    input = _a;
+                    return [4 /*yield*/, collectImportPlansForDatasource(datasource, input.rows, {
+                            createMissing: options.createMissing === true,
+                            prune: options.prune === true,
+                        }, undefined, input.warnings)];
+                case 5:
+                    collected = _b.sent();
+                    if (!(options.apply === true)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, writePlans(datasource, collected.plans)];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7: return [2 /*return*/, createResult(inputFilePath, options.apply === true, startTime, input.rowCount, collected.plans, collected.skippedRows, collected.skippedCells, collected.prunedTranslations, input.warnings)];
+            }
+        });
+    });
+}
+function importProjectSets(projectConfig_1, datasource_1) {
+    return __awaiter(this, arguments, void 0, function (projectConfig, datasource, options, parsed) {
+        var startTime, requestedSets, executions, executionSets, unknownRequestedSets, inputFilePath, locale, execution_1, localeKeys, input, warnings_1, collected, csv, selectedExecutions, hasSetColumn, localeKeysBySet, allLocaleKeys, requestedLocales, localeHeaders, unknownHeaders, warnings, rows, rowsBySet, skippedRows, skippedCells, _i, rows_1, row, rowSet, plans, prunedTranslations, _a, selectedExecutions_1, execution, setRows, collected;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    startTime = Date.now();
+                    assertOptions(options);
+                    if (!projectConfig.sets) {
+                        return [2 /*return*/, importProject(projectConfig, datasource, options, parsed)];
+                    }
+                    requestedSets = toArray(options.set);
+                    return [4 /*yield*/, (0, sets_1.getProjectSetExecutions)(projectConfig, datasource, undefined)];
+                case 1:
+                    executions = _b.sent();
+                    executionSets = executions.map(function (execution) { return execution.set; });
+                    unknownRequestedSets = requestedSets.filter(function (set) { return !executionSets.includes(set); });
+                    inputFilePath = getInputFilePath(projectConfig, options, parsed);
+                    if (unknownRequestedSets.length > 0) {
+                        throw new error_1.MessagevisorCLIError("Unknown set \"".concat(unknownRequestedSets[0], "\". Available sets: ").concat(executionSets.join(", ") || "none", "."));
+                    }
+                    if (!options.fromJson) return [3 /*break*/, 7];
+                    if (requestedSets.length !== 1) {
+                        throw new error_1.MessagevisorCLIError("--from-json requires exactly one --set=<set> when `sets: true` is configured.");
+                    }
+                    locale = getJsonImportLocale(options);
+                    execution_1 = executions.find(function (currentExecution) { return currentExecution.set === requestedSets[0]; });
+                    return [4 /*yield*/, execution_1.datasource.listLocales()];
+                case 2:
+                    localeKeys = _b.sent();
+                    assertKnownLocales([locale], localeKeys);
+                    return [4 /*yield*/, readJsonImportInput(projectConfig, inputFilePath, locale, options)];
+                case 3:
+                    input = _b.sent();
+                    warnings_1 = __spreadArray([], input.warnings, true);
+                    return [4 /*yield*/, collectImportPlansForDatasource(execution_1.datasource, input.rows.map(function (row) { return (__assign(__assign({}, row), { set: execution_1.set })); }), {
+                            createMissing: options.createMissing === true,
+                            prune: options.prune === true,
+                        }, execution_1.set, warnings_1)];
+                case 4:
+                    collected = _b.sent();
+                    if (!(options.apply === true)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, writePlans(execution_1.datasource, collected.plans)];
+                case 5:
+                    _b.sent();
+                    _b.label = 6;
+                case 6: return [2 /*return*/, createResult(inputFilePath, options.apply === true, startTime, input.rowCount, collected.plans, collected.skippedRows, collected.skippedCells, collected.prunedTranslations, warnings_1)];
+                case 7: return [4 /*yield*/, readCsv(inputFilePath, options)];
+                case 8:
+                    csv = _b.sent();
+                    selectedExecutions = requestedSets.length > 0
+                        ? executions.filter(function (execution) { return requestedSets.includes(execution.set); })
+                        : executions;
+                    hasSetColumn = csv.headers.includes("set");
+                    if (!hasSetColumn && requestedSets.length !== 1) {
+                        throw new error_1.MessagevisorCLIError('CSV without a "set" column requires exactly one --set=<set>.');
+                    }
+                    return [4 /*yield*/, getAllLocaleKeysBySet(selectedExecutions)];
+                case 9:
+                    localeKeysBySet = _b.sent();
+                    allLocaleKeys = Array.from(new Set(localeKeysBySet.flatMap(function (entry) { return entry.locales; })));
+                    requestedLocales = toArray(options.locale);
+                    localeHeaders = getSelectedLocaleHeaders(csv.headers, allLocaleKeys, requestedLocales);
+                    unknownHeaders = getUnknownTranslationHeaders(csv.headers, allLocaleKeys);
+                    warnings = unknownHeaders.map(function (header) { return "Ignoring unknown CSV column \"".concat(header, "\"."); });
+                    rows = toImportRows(projectConfig, csv, localeHeaders);
+                    rowsBySet = new Map();
+                    skippedRows = 0;
+                    skippedCells = 0;
+                    for (_i = 0, rows_1 = rows; _i < rows_1.length; _i++) {
+                        row = rows_1[_i];
+                        rowSet = hasSetColumn ? row.set : requestedSets[0];
+                        if (!rowSet) {
+                            skippedRows++;
+                            addWarning(warnings, "Row ".concat(row.rowNumber, ": missing set."));
+                            continue;
+                        }
+                        if (!executionSets.includes(rowSet)) {
+                            skippedRows++;
+                            addWarning(warnings, "Row ".concat(row.rowNumber, ": unknown set \"").concat(rowSet, "\"."));
+                            continue;
+                        }
+                        if (requestedSets.length > 0 && !requestedSets.includes(rowSet)) {
+                            skippedRows++;
+                            continue;
+                        }
+                        rowsBySet.set(rowSet, __spreadArray(__spreadArray([], (rowsBySet.get(rowSet) || []), true), [__assign(__assign({}, row), { set: rowSet })], false));
+                    }
+                    plans = [];
+                    prunedTranslations = 0;
+                    _a = 0, selectedExecutions_1 = selectedExecutions;
+                    _b.label = 10;
+                case 10:
+                    if (!(_a < selectedExecutions_1.length)) return [3 /*break*/, 14];
+                    execution = selectedExecutions_1[_a];
+                    setRows = rowsBySet.get(execution.set) || [];
+                    if (setRows.length === 0) {
+                        return [3 /*break*/, 13];
+                    }
+                    return [4 /*yield*/, collectImportPlansForDatasource(execution.datasource, setRows, {
+                            createMissing: options.createMissing === true,
+                            prune: options.prune === true,
+                        }, execution.set, warnings)];
+                case 11:
+                    collected = _b.sent();
+                    plans.push.apply(plans, collected.plans);
+                    skippedRows += collected.skippedRows;
+                    skippedCells += collected.skippedCells;
+                    prunedTranslations += collected.prunedTranslations;
+                    if (!(options.apply === true)) return [3 /*break*/, 13];
+                    return [4 /*yield*/, writePlans(execution.datasource, collected.plans)];
+                case 12:
+                    _b.sent();
+                    _b.label = 13;
+                case 13:
+                    _a++;
+                    return [3 /*break*/, 10];
+                case 14: return [2 /*return*/, createResult(inputFilePath, options.apply === true, startTime, rows.length, plans, skippedRows, skippedCells, prunedTranslations, warnings)];
+            }
+        });
+    });
+}
+function printImportResult(result) {
+    console.log("");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Importing Messagevisor translations");
+    var inputLabel = isHttpUrl(result.inputFilePath)
+        ? result.inputFilePath
+        : path.relative(process.cwd(), result.inputFilePath);
+    console.log("  Input: ".concat((0, cliFormat_1.colorize)(inputLabel, 36)));
+    console.log("  Mode: ".concat(result.apply ? "apply" : "preview"));
+    if (result.summary.sets.length > 0) {
+        console.log("  Sets: ".concat(result.summary.sets.join(", ")));
+    }
+    console.log("");
+    console.log("  Rows:                  ".concat(result.summary.rows));
+    console.log("  Changed messages:      ".concat(result.summary.changedMessages));
+    console.log("  Changed overrides:     ".concat(result.summary.changedOverrides));
+    console.log("  Created messages:      ".concat(result.summary.createdMessages));
+    console.log("  Created overrides:     ".concat(result.summary.createdOverrides));
+    console.log("  Changed translations:  ".concat(result.summary.changedTranslations));
+    console.log("  Pruned translations:   ".concat(result.summary.prunedTranslations));
+    console.log("  Skipped rows:          ".concat(result.summary.skippedRows));
+    console.log("  Skipped cells:         ".concat(result.summary.skippedCells));
+    console.log("  Warnings:              ".concat(result.summary.warnings));
+    console.log("");
+    if (result.warnings.length > 0) {
+        console.log(cliFormat_1.CLI_FORMAT_BOLD, "Warnings");
+        for (var _i = 0, _a = result.warnings.slice(0, 12); _i < _a.length; _i++) {
+            var warning = _a[_i];
+            console.log(cliFormat_1.CLI_FORMAT_YELLOW, "  ".concat(warning));
+        }
+        if (result.warnings.length > 12) {
+            console.log("  ".concat((0, cliFormat_1.colorize)("...and ".concat(result.warnings.length - 12, " more"), 2)));
+        }
+        console.log("");
+    }
+    console.log(cliFormat_1.CLI_FORMAT_GREEN, result.apply ? "Import applied" : "Import preview complete");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Time: ".concat((0, prettyDuration_1.prettyDuration)(result.duration)));
+}
+exports.importPlugin = {
+    command: "import [input]",
+    handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var result, error_3;
+        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*/, importProjectSets(projectConfig, datasource, {
+                            input: parsed.input || parsed.csvFilePath,
+                            set: parsed.set,
+                            locale: parsed.locale,
+                            createMissing: parsed.createMissing,
+                            apply: parsed.apply === true || parsed.apply === "true",
+                            prune: parsed.prune === true || parsed.prune === "true",
+                            fromJson: parsed.fromJson === true || parsed.fromJson === "true",
+                            jsonPath: parsed.jsonPath,
+                            delimiter: parsed.delimiter,
+                            bom: parsed.bom,
+                        }, parsed)];
+                case 1:
+                    result = _c.sent();
+                    printImportResult(result);
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_3 = _c.sent();
+                    if ((0, error_1.printMessagevisorCLIError)(error_3)) {
+                        return [2 /*return*/, false];
+                    }
+                    throw error_3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); },
+    examples: [
+        {
+            command: "import exports/messagevisor-export-20260419T123456.csv",
+            description: "preview translations from a CSV file",
+        },
+        {
+            command: "import --input=translator/nl.csv --apply",
+            description: "apply an import and write message files",
+        },
+        {
+            command: "import --input=translator/translations.csv --locale=nl --apply",
+            description: "apply only one locale column from a CSV",
+        },
+        {
+            command: "import --input=translator/translations.csv --locale=en-US --prune --apply",
+            description: "apply an import while pruning translations duplicated by inheritance",
+        },
+        {
+            command: "import translations.csv --set=staging",
+            description: "preview a CSV without a set column for one set",
+        },
+        {
+            command: "import translations.json --from-json --locale=nl-NL --apply",
+            description: "apply translations from a flat JSON object",
+        },
+    ],
+};
+//# sourceMappingURL=index.js.map