keycloakify 11.0.1 → 11.1.0

package/bin/499.index.js

@@ -785,6 +785,9 @@ var escapeStringForPropertiesFile = __webpack_require__(27190);
 // EXTERNAL MODULE: external "child_process"
 var external_child_process_ = __webpack_require__(32081);
 var external_child_process_default = /*#__PURE__*/__webpack_require__.n(external_child_process_);
+// EXTERNAL MODULE: ./node_modules/properties-parser/index.js
+var properties_parser = __webpack_require__(44414);
+var properties_parser_default = /*#__PURE__*/__webpack_require__.n(properties_parser);
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateResources/generateResourcesForMainTheme.js
 
 
@@ -804,6 +807,7 @@ var external_child_process_default = /*#__PURE__*/__webpack_require__.n(external
 
 
 
+
 (0,assert.assert)();
 async function generateResourcesForMainTheme(params) {
     var _a;
@@ -937,14 +941,38 @@ async function generateResourcesForMainTheme(params) {
             })
                 .toString("utf8")
                 .trim();
-            const messagesDirPath = (0,external_path_.join)(accountUiDirPath, "messages");
-            if (!external_fs_.existsSync(messagesDirPath)) {
+            const messageDirPath_defaults = (0,external_path_.join)(accountUiDirPath, "messages");
+            if (!external_fs_.existsSync(messageDirPath_defaults)) {
                 throw new Error(`Please update @keycloakify/keycloak-account-ui to 25.0.4-rc.5 or later.`);
             }
+            const messagesDirPath_dest = (0,external_path_.join)(getThemeTypeDirPath({ themeType: "account" }), "messages");
             (0,transformCodebase/* transformCodebase */.N)({
-                srcDirPath: messagesDirPath,
-                destDirPath: (0,external_path_.join)(getThemeTypeDirPath({ themeType: "account" }), "messages")
+                srcDirPath: messageDirPath_defaults,
+                destDirPath: messagesDirPath_dest
             });
+            apply_theme_changes: {
+                const messagesDirPath_theme = (0,external_path_.join)(buildContext.themeSrcDirPath, "account", "messages");
+                if (!external_fs_.existsSync(messagesDirPath_theme)) {
+                    break apply_theme_changes;
+                }
+                external_fs_.readdirSync(messagesDirPath_theme).forEach(basename => {
+                    const filePath_src = (0,external_path_.join)(messagesDirPath_theme, basename);
+                    const filePath_dest = (0,external_path_.join)(messagesDirPath_dest, basename);
+                    if (!external_fs_.existsSync(filePath_dest)) {
+                        external_fs_.cpSync(filePath_src, filePath_dest);
+                    }
+                    const messages_src = properties_parser_default().parse(external_fs_.readFileSync(filePath_src).toString("utf8"));
+                    const messages_dest = properties_parser_default().parse(external_fs_.readFileSync(filePath_dest).toString("utf8"));
+                    const messages = Object.assign(Object.assign({}, messages_dest), messages_src);
+                    const editor = properties_parser_default().createEditor();
+                    Object.entries(messages).forEach(([key, value]) => {
+                        editor.set(key, value);
+                    });
+                    external_fs_.writeFileSync(filePath_dest, Buffer.from(editor.toString(), "utf8"));
+                });
+            }
+            languageTags = external_fs_.readdirSync(messagesDirPath_dest)
+                .map(basename => basename.replace(/^messages_/, "").replace(/\.properties$/, ""));
         }
         keycloak_static_resources: {
             if (isForAccountSpa) {

package/bin/{246.index.js → 860.index.js}

@@ -1,5 +1,5 @@
-exports.id = 246;
-exports.ids = [246];
+exports.id = 860;
+exports.ids = [860];
 exports.modules = {
 
 /***/ 15573:
@@ -9292,6 +9292,434 @@ jsesc.version = '2.5.2';
 module.exports = jsesc;
 
 
+/***/ }),
+
+/***/ 44414:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(21360);
+var fs = __webpack_require__(57147);
+
+function Iterator(text) {
+	var pos = 0, length = text.length;
+
+	this.peek = function(num) {
+		num = num || 0;
+		if(pos + num >= length) { return null; }
+
+		return text.charAt(pos + num);
+	};
+	this.next = function(inc) {
+		inc = inc || 1;
+
+		if(pos >= length) { return null; }
+
+		return text.charAt((pos += inc) - inc);
+	};
+	this.pos = function() {
+		return pos;
+	};
+}
+
+var rWhitespace = /\s/;
+function isWhitespace(chr) {
+	return rWhitespace.test(chr);
+}
+function consumeWhiteSpace(iter) {
+	var start = iter.pos();
+
+	while(isWhitespace(iter.peek())) { iter.next(); }
+
+	return { type: "whitespace", start: start, end: iter.pos() };
+}
+
+function startsComment(chr) {
+	return chr === "!" || chr === "#";
+}
+function isEOL(chr) {
+	return chr == null || chr === "\n" || chr === "\r";
+}
+function consumeComment(iter) {
+	var start = iter.pos();
+
+	while(!isEOL(iter.peek())) { iter.next(); }
+
+	return { type: "comment", start: start, end: iter.pos() };
+}
+
+function startsKeyVal(chr) {
+	return !isWhitespace(chr) && !startsComment(chr);
+}
+function startsSeparator(chr) {
+	return chr === "=" || chr === ":" || isWhitespace(chr);
+}
+function startsEscapedVal(chr) {
+	return chr === "\\";
+}
+function consumeEscapedVal(iter) {
+	var start = iter.pos();
+
+	iter.next(); // move past "\"
+	var curChar = iter.next();
+	if(curChar === "u") { // encoded unicode char
+		iter.next(4); // Read in the 4 hex values
+	}
+
+	return { type: "escaped-value", start: start, end: iter.pos() };
+}
+function consumeKey(iter) {
+	var start = iter.pos(), children = [];
+
+	var curChar;
+	while((curChar = iter.peek()) !== null) {
+		if(startsSeparator(curChar)) { break; }
+		if(startsEscapedVal(curChar)) { children.push(consumeEscapedVal(iter)); continue; }
+
+		iter.next();
+	}
+
+	return { type: "key", start: start, end: iter.pos(), children: children };
+}
+function consumeKeyValSeparator(iter) {
+	var start = iter.pos();
+
+	var seenHardSep = false, curChar;
+	while((curChar = iter.peek()) !== null) {
+		if(isEOL(curChar)) { break; }
+
+		if(isWhitespace(curChar)) { iter.next(); continue; }
+
+		if(seenHardSep) { break; }
+
+		seenHardSep = (curChar === ":" || curChar === "=");
+		if(seenHardSep) { iter.next(); continue; }
+
+		break; // curChar is a non-separtor char
+	}
+
+	return { type: "key-value-separator", start: start, end: iter.pos() };
+}
+function startsLineBreak(iter) {
+	return iter.peek() === "\\" && isEOL(iter.peek(1));
+}
+function consumeLineBreak(iter) {
+	var start = iter.pos();
+
+	iter.next(); // consume \
+	if(iter.peek() === "\r") { iter.next(); }
+	iter.next(); // consume \n
+
+	var curChar;
+	while((curChar = iter.peek()) !== null) {
+		if(isEOL(curChar)) { break; }
+		if(!isWhitespace(curChar)) { break; }
+
+		iter.next();
+	}
+
+	return { type: "line-break", start: start, end: iter.pos() };
+}
+function consumeVal(iter) {
+	var start = iter.pos(), children = [];
+
+	var curChar;
+	while((curChar = iter.peek()) !== null) {
+		if(startsLineBreak(iter)) { children.push(consumeLineBreak(iter)); continue; }
+		if(startsEscapedVal(curChar)) { children.push(consumeEscapedVal(iter)); continue; }
+		if(isEOL(curChar)) { break; }
+
+		iter.next();
+	}
+
+	return { type: "value", start: start, end: iter.pos(), children: children };
+}
+function consumeKeyVal(iter) {
+	return {
+		type: "key-value",
+		start: iter.pos(),
+		children: [
+			consumeKey(iter),
+			consumeKeyValSeparator(iter),
+			consumeVal(iter)
+		],
+		end: iter.pos()
+	};
+}
+
+var renderChild = {
+	"escaped-value": function(child, text) {
+		var type = text.charAt(child.start + 1);
+
+		if(type === "t") { return "\t"; }
+		if(type === "r") { return "\r"; }
+		if(type === "n") { return "\n"; }
+		if(type === "f") { return "\f"; }
+		if(type !== "u") { return type; }
+
+		return String.fromCharCode(parseInt(text.substr(child.start + 2, 4), 16));
+	},
+	"line-break": function (child, text) {
+		return "";
+	}
+};
+function rangeToBuffer(range, text) {
+	var start = range.start, buffer = [];
+
+	for(var i = 0; i < range.children.length; i++) {
+		var child = range.children[i];
+
+		buffer.push(text.substring(start, child.start));
+		buffer.push(renderChild[child.type](child, text));
+		start = child.end;
+	}
+	buffer.push(text.substring(start, range.end));
+
+	return buffer;
+}
+function rangesToObject(ranges, text) {
+	var obj = Object.create(null); // Creates to a true hash map
+
+	for(var i = 0; i < ranges.length; i++) {
+		var range = ranges[i];
+
+		if(range.type !== "key-value") { continue; }
+
+		var key = rangeToBuffer(range.children[0], text).join("");
+		var val = rangeToBuffer(range.children[2], text).join("");
+		obj[key] = val;
+	}
+
+	return obj;
+}
+
+function stringToRanges(text) {
+	var iter = new Iterator(text), ranges = [];
+
+	var curChar;
+	while((curChar = iter.peek()) !== null) {
+		if(isWhitespace(curChar)) { ranges.push(consumeWhiteSpace(iter)); continue; }
+		if(startsComment(curChar)) { ranges.push(consumeComment(iter)); continue; }
+		if(startsKeyVal(curChar)) { ranges.push(consumeKeyVal(iter)); continue; }
+
+		throw Error("Something crazy happened. text: '" + text + "'; curChar: '" + curChar + "'");
+	}
+
+	return ranges;
+}
+
+function isNewLineRange(range) {
+	if(!range) { return false; }
+
+	if(range.type === "whitespace") { return true; }
+
+	if(range.type === "literal") {
+		return isWhitespace(range.text) && range.text.indexOf("\n") > -1;
+	}
+
+	return false;
+}
+
+function escapeMaker(escapes) {
+	return function escapeKey(key) {
+		var zeros = [ "", "0", "00", "000" ];
+		var buf = [];
+
+		for(var i = 0; i < key.length; i++) {
+			var chr = key.charAt(i);
+
+			if(escapes[chr]) { buf.push(escapes[chr]); continue; }
+
+			var code = chr.codePointAt(0);
+
+			if(code <= 0x7F) { buf.push(chr); continue; }
+
+			var hex = code.toString(16);
+
+			buf.push("\\u");
+			buf.push(zeros[4 - hex.length]);
+			buf.push(hex);
+		}
+
+		return buf.join("");
+	};
+}
+
+var escapeKey = escapeMaker({ " ": "\\ ", "\n": "\\n", ":": "\\:", "=": "\\=" });
+var escapeVal = escapeMaker({ "\n": "\\n" });
+
+function Editor(text, options) {
+    if (typeof text === 'object') {
+        options = text;
+        text = null;
+    }
+	text = text || "";
+    var path = options.path;
+    var separator = options.separator || '=';
+
+	var ranges = stringToRanges(text);
+	var obj = rangesToObject(ranges, text);
+	var keyRange = Object.create(null); // Creates to a true hash map
+
+	for(var i = 0; i < ranges.length; i++) {
+		var range = ranges[i];
+
+		if(range.type !== "key-value") { continue; }
+
+		var key = rangeToBuffer(range.children[0], text).join("");
+		keyRange[key] = range;
+	}
+
+	this.addHeadComment = function(comment) {
+		if(comment == null) { return; }
+
+		ranges.unshift({ type: "literal", text: "# " + comment.replace(/\n/g, "\n# ") + "\n" });
+	};
+
+	this.get = function(key) { return obj[key]; };
+	this.set = function(key, val, comment) {
+		if(val == null) { this.unset(key); return; }
+
+		obj[key] = val;
+		var escapedKey = escapeKey(key);
+		var escapedVal = escapeVal(val);
+
+		var range = keyRange[key];
+		if(!range) {
+			keyRange[key] = range = {
+				type: "literal",
+				text: escapedKey + separator + escapedVal
+			};
+
+			var prevRange = ranges[ranges.length - 1];
+			if(prevRange != null && !isNewLineRange(prevRange)) {
+				ranges.push({ type: "literal", text: "\n" });
+			}
+			ranges.push(range);
+		}
+
+		// comment === null deletes comment. if comment === undefined, it's left alone
+		if(comment !== undefined) {
+			range.comment = comment && "# " + comment.replace(/\n/g, "\n# ") + "\n";
+		}
+
+		if(range.type === "literal") {
+			range.text = escapedKey + separator + escapedVal;
+			if(range.comment != null) { range.text = range.comment + range.text; }
+		} else if(range.type === "key-value") {
+			range.children[2] = { type: "literal", text: escapedVal };
+		} else {
+			throw "Unknown node type: " + range.type;
+		}
+	};
+	this.unset = function(key) {
+		if(!(key in obj)) { return; }
+
+		var range = keyRange[key];
+		var idx = ranges.indexOf(range);
+
+		ranges.splice(idx, (isNewLineRange(ranges[idx + 1]) ? 2 : 1));
+
+		delete keyRange[key];
+		delete obj[key];
+	};
+	this.valueOf = this.toString = function() {
+		var buffer = [], stack = [].concat(ranges);
+
+		var node;
+		while((node = stack.shift()) != null) {
+			switch(node.type) {
+				case "literal":
+					buffer.push(node.text);
+					break;
+				case "key":
+				case "value":
+				case "comment":
+				case "whitespace":
+				case "key-value-separator":
+				case "escaped-value":
+				case "line-break":
+					buffer.push(text.substring(node.start, node.end));
+					break;
+				case "key-value":
+					Array.prototype.unshift.apply(stack, node.children);
+					if(node.comment) { stack.unshift({ type: "literal", text: node.comment }); }
+					break;
+			}
+		}
+
+		return buffer.join("");
+	};
+	this.save = function(newPath, callback) {
+		if(typeof newPath === 'function') {
+			callback = newPath;
+			newPath = path;
+		}
+		newPath = newPath || path;
+
+		if(!newPath) {
+            if (callback) {
+                return callback("Unknown path");
+            }
+            throw new Error("Unknown path");
+        }
+
+        if (callback) {
+            fs.writeFile(newPath, this.toString(), callback);
+        } else {
+            fs.writeFileSync(newPath, this.toString());
+        }
+
+	};
+}
+function createEditor(/*path, options, callback*/) {
+    var path, options, callback;
+    var args = Array.prototype.slice.call(arguments);
+    for (var i = 0; i < args.length; i ++) {
+        var arg = args[i];
+        if (!path && typeof arg === 'string') {
+            path = arg;
+        } else if (!options && typeof arg === 'object') {
+            options = arg;
+        } else if (!callback && typeof arg === 'function') {
+            callback = arg;
+        }
+    }
+    options = options || {};
+    path = path || options.path;
+    callback = callback || options.callback;
+    options.path = path;
+
+	if(!path) { return new Editor(options); }
+
+	if(!callback) { return new Editor(fs.readFileSync(path).toString(), options); }
+
+	return fs.readFile(path, function(err, text) {
+		if(err) { return callback(err, null); }
+
+		text = text.toString();
+		return callback(null, new Editor(text, options));
+	});
+}
+
+function parse(text) {
+	text = text.toString();
+	var ranges = stringToRanges(text);
+	return rangesToObject(ranges, text);
+}
+
+function read(path, callback) {
+	if(!callback) { return parse(fs.readFileSync(path)); }
+
+	return fs.readFile(path, function(err, data) {
+		if(err) { return callback(err, null); }
+
+		return callback(null, parse(data));
+	});
+}
+
+module.exports = { parse: parse, read: read, createEditor: createEditor };
+
+
 /***/ }),
 
 /***/ 11346:
@@ -22663,6 +23091,67 @@ exports.SourceMapConsumer = __webpack_require__(75155).SourceMapConsumer;
 exports.SourceNode = __webpack_require__(92616).SourceNode;
 
 
+/***/ }),
+
+/***/ 21360:
+/***/ (() => {
+
+/*! https://mths.be/codepointat v0.2.0 by @mathias */
+if (!String.prototype.codePointAt) {
+	(function() {
+		'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
+		var defineProperty = (function() {
+			// IE 8 only supports `Object.defineProperty` on DOM elements
+			try {
+				var object = {};
+				var $defineProperty = Object.defineProperty;
+				var result = $defineProperty(object, object, object) && $defineProperty;
+			} catch(error) {}
+			return result;
+		}());
+		var codePointAt = function(position) {
+			if (this == null) {
+				throw TypeError();
+			}
+			var string = String(this);
+			var size = string.length;
+			// `ToInteger`
+			var index = position ? Number(position) : 0;
+			if (index != index) { // better `isNaN`
+				index = 0;
+			}
+			// Account for out-of-bounds indices:
+			if (index < 0 || index >= size) {
+				return undefined;
+			}
+			// Get the first code unit
+			var first = string.charCodeAt(index);
+			var second;
+			if ( // check if it’s the start of a surrogate pair
+				first >= 0xD800 && first <= 0xDBFF && // high surrogate
+				size > index + 1 // there is a next code unit
+			) {
+				second = string.charCodeAt(index + 1);
+				if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
+					// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+					return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+				}
+			}
+			return first;
+		};
+		if (defineProperty) {
+			defineProperty(String.prototype, 'codePointAt', {
+				'value': codePointAt,
+				'configurable': true,
+				'writable': true
+			});
+		} else {
+			String.prototype.codePointAt = codePointAt;
+		}
+	}());
+}
+
+
 /***/ }),
 
 /***/ 19049:

package/bin/main.js

@@ -11312,7 +11312,7 @@ program
     .task({
     skip,
     handler: async (cliCommandOptions) => {
-        const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(941), __nccwpck_require__.e(246), __nccwpck_require__.e(31), __nccwpck_require__.e(499)]).then(__nccwpck_require__.bind(__nccwpck_require__, 70499));
+        const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(941), __nccwpck_require__.e(860), __nccwpck_require__.e(31), __nccwpck_require__.e(499)]).then(__nccwpck_require__.bind(__nccwpck_require__, 70499));
         await command({ cliCommandOptions });
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "11.0.1",
+    "version": "11.1.0",
     "description": "Framework to create custom Keycloak UIs",
     "repository": {
         "type": "git",
@@ -981,7 +981,6 @@
         "bin/main.js",
         "bin/193.index.js",
         "bin/20.index.js",
-        "bin/246.index.js",
         "bin/266.index.js",
         "bin/304.index.js",
         "bin/31.index.js",
@@ -995,6 +994,7 @@
         "bin/743.index.js",
         "bin/780.index.js",
         "bin/786.index.js",
+        "bin/860.index.js",
         "bin/877.index.js",
         "bin/903.index.js",
         "bin/932.index.js",
@@ -1040,6 +1040,7 @@
         "@babel/core": "^7.24.5",
         "@babel/generator": "^7.24.5",
         "@babel/parser": "^7.24.5",
+        "@babel/preset-env": "7.24.8",
         "@babel/types": "^7.24.5",
         "@emotion/react": "^11.11.4",
         "@octokit/rest": "^20.1.1",
@@ -1047,20 +1048,27 @@
         "@storybook/builder-webpack5": "^6.5.13",
         "@storybook/manager-webpack5": "^6.5.13",
         "@storybook/react": "^6.5.13",
-        "eslint-plugin-storybook": "^0.6.7",
         "@types/babel__generator": "^7.6.4",
+        "@types/dompurify": "^2.0.0",
         "@types/make-fetch-happen": "^10.0.1",
         "@types/minimist": "^1.2.2",
         "@types/node": "^18.15.3",
+        "@types/properties-parser": "^0.3.3",
         "@types/react": "^18.0.35",
         "@types/react-dom": "^18.0.11",
         "@types/yauzl": "^2.10.3",
         "@vercel/ncc": "^0.38.1",
+        "babel-loader": "9.1.3",
         "chalk": "^4.1.2",
         "cheerio": "1.0.0-rc.12",
         "chokidar-cli": "^3.0.0",
         "cli-select": "^1.1.2",
+        "dompurify": "^3.1.6",
+        "eslint-plugin-storybook": "^0.6.7",
+        "evt": "^2.5.7",
+        "html-entities": "^2.5.2",
         "husky": "^4.3.8",
+        "isomorphic-dompurify": "^2.15.0",
         "lint-staged": "^11.0.0",
         "magic-string": "^0.30.7",
         "make-fetch-happen": "^11.0.3",
@@ -1075,20 +1083,13 @@
         "termost": "^v0.12.1",
         "tsc-alias": "^1.8.10",
         "tss-react": "^4.9.10",
+        "tsx": "^4.15.5",
         "typescript": "^4.9.4",
         "vite": "^5.2.11",
         "vitest": "^1.6.0",
-        "yauzl": "^2.10.0",
-        "zod": "^3.17.10",
-        "evt": "^2.5.7",
-        "tsx": "^4.15.5",
-        "html-entities": "^2.5.2",
-        "isomorphic-dompurify": "^2.15.0",
-        "dompurify": "^3.1.6",
-        "@types/dompurify": "^2.0.0",
         "webpack": "5.93.0",
         "webpack-cli": "5.1.4",
-        "babel-loader": "9.1.3",
-        "@babel/preset-env": "7.24.8"
+        "yauzl": "^2.10.0",
+        "zod": "^3.17.10"
     }
 }

package/src/bin/keycloakify/generateResources/generateResourcesForMainTheme.ts

@@ -31,6 +31,7 @@ import { objectEntries } from "tsafe/objectEntries";
 import { escapeStringForPropertiesFile } from "../../tools/escapeStringForPropertiesFile";
 import * as child_process from "child_process";
 import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
+import propertiesParser from "properties-parser";
 
 export type BuildContextLike = BuildContextLike_kcContextExclusionsFtlCode &
     BuildContextLike_generateMessageProperties & {
@@ -239,21 +240,73 @@ export async function generateResourcesForMainTheme(params: {
                 .toString("utf8")
                 .trim();
 
-            const messagesDirPath = pathJoin(accountUiDirPath, "messages");
+            const messageDirPath_defaults = pathJoin(accountUiDirPath, "messages");
 
-            if (!fs.existsSync(messagesDirPath)) {
+            if (!fs.existsSync(messageDirPath_defaults)) {
                 throw new Error(
                     `Please update @keycloakify/keycloak-account-ui to 25.0.4-rc.5 or later.`
                 );
             }
 
+            const messagesDirPath_dest = pathJoin(
+                getThemeTypeDirPath({ themeType: "account" }),
+                "messages"
+            );
+
             transformCodebase({
-                srcDirPath: messagesDirPath,
-                destDirPath: pathJoin(
-                    getThemeTypeDirPath({ themeType: "account" }),
-                    "messages"
-                )
+                srcDirPath: messageDirPath_defaults,
+                destDirPath: messagesDirPath_dest
             });
+
+            apply_theme_changes: {
+                const messagesDirPath_theme = pathJoin(
+                    buildContext.themeSrcDirPath,
+                    "account",
+                    "messages"
+                );
+
+                if (!fs.existsSync(messagesDirPath_theme)) {
+                    break apply_theme_changes;
+                }
+
+                fs.readdirSync(messagesDirPath_theme).forEach(basename => {
+                    const filePath_src = pathJoin(messagesDirPath_theme, basename);
+                    const filePath_dest = pathJoin(messagesDirPath_dest, basename);
+
+                    if (!fs.existsSync(filePath_dest)) {
+                        fs.cpSync(filePath_src, filePath_dest);
+                    }
+
+                    const messages_src = propertiesParser.parse(
+                        fs.readFileSync(filePath_src).toString("utf8")
+                    );
+                    const messages_dest = propertiesParser.parse(
+                        fs.readFileSync(filePath_dest).toString("utf8")
+                    );
+
+                    const messages = {
+                        ...messages_dest,
+                        ...messages_src
+                    };
+
+                    const editor = propertiesParser.createEditor();
+
+                    Object.entries(messages).forEach(([key, value]) => {
+                        editor.set(key, value);
+                    });
+
+                    fs.writeFileSync(
+                        filePath_dest,
+                        Buffer.from(editor.toString(), "utf8")
+                    );
+                });
+            }
+
+            languageTags = fs
+                .readdirSync(messagesDirPath_dest)
+                .map(basename =>
+                    basename.replace(/^messages_/, "").replace(/\.properties$/, "")
+                );
         }
 
         keycloak_static_resources: {