keycloakify 10.0.0-rc.107 → 10.0.0-rc.109

package/src/account/i18n/i18n.tsx

@@ -1,22 +1,24 @@
 import "keycloakify/tools/Object.fromEntries";
 import { assert } from "tsafe/assert";
-import messages_fallbackLanguage from "./baseMessages/en";
-import { getMessages } from "./baseMessages";
+import messages_defaultSet_fallbackLanguage from "./messages_defaultSet/en";
+import { fetchMessages_defaultSet } from "./messages_defaultSet";
 import type { KcContext } from "../KcContext";
 import { fallbackLanguageTag } from "keycloakify/bin/shared/constants";
+import { id } from "tsafe/id";
 
 export type KcContextLike = {
     locale?: {
         currentLanguageTag: string;
         supported: { languageTag: string; url: string; label: string }[];
     };
+    "x-keycloakify": {
+        messages: Record<string, string>;
+    };
 };
 
 assert<KcContext extends KcContextLike ? true : false>();
 
-export type MessageKey = keyof typeof messages_fallbackLanguage;
-
-export type GenericI18n<MessageKey extends string> = {
+export type GenericI18n_noJsx<MessageKey extends string> = {
     /**
      * e.g: "en", "fr", "zh-CN"
      *
@@ -36,16 +38,21 @@ export type GenericI18n<MessageKey extends string> = {
      * */
     labelBySupportedLanguageTag: Record<string, string>;
     /**
+     *
      * Examples assuming currentLanguageTag === "en"
+     * {
+     *   en: {
+     *     "access-denied": "Access denied",
+     *     "impersonateTitleHtml": "<strong>{0}</strong> Impersonate User",
+     *     "bar": "Bar {0}"
+     *   }
+     * }
      *
-     * msg("access-denied") === <span>Access denied</span>
-     * msg("impersonateTitleHtml", "Foo") === <span><strong>Foo</strong> Impersonate User</span>
-     */
-    msg: (key: MessageKey, ...args: (string | undefined)[]) => JSX.Element;
-    /**
-     * It's the same thing as msg() but instead of returning a JSX.Element it returns a string.
-     * It can be more convenient to manipulate strings but if there are HTML tags it wont render.
+     * msgStr("access-denied") === "Access denied"
+     * msgStr("not-a-message-key") Throws an error
      * msgStr("impersonateTitleHtml", "Foo") === "<strong>Foo</strong> Impersonate User"
+     * msgStr("${bar}", "<strong>c</strong>") === "Bar &lt;strong&gt;XXX&lt;/strong&gt;"
+     *  The html in the arg is partially escaped for security reasons, it might come from an untrusted source, it's not safe to render it as html.
      */
     msgStr: (key: MessageKey, ...args: (string | undefined)[]) => string;
     /**
@@ -56,24 +63,11 @@ export type GenericI18n<MessageKey extends string> = {
      * {
      *   en: {
      *     "access-denied": "Access denied",
-     *     "foo": "Foo {0} {1}",
-     *     "bar": "Bar {0}"
      *   }
      * }
      *
-     * advancedMsg("${access-denied} foo bar") === <span>{msgStr("access-denied")} foo bar<span> === <span>Access denied foo bar</span>
-     * advancedMsg("${access-denied}") === advancedMsg("access-denied") === msg("access-denied") === <span>Access denied</span>
-     * advancedMsg("${not-a-message-key}") === advancedMsg(not-a-message-key") === <span>not-a-message-key</span>
-     * advancedMsg("${bar}", "<strong>c</strong>")
-     *    === <span>{msgStr("bar", "<strong>XXX</strong>")}<span>
-     *    === <span>Bar &lt;strong&gt;XXX&lt;/strong&gt;</span> (The html in the arg is partially escaped for security reasons, it might be untrusted)
-     * advancedMsg("${foo} xx ${bar}", "a", "b", "c")
-     *    === <span>{msgStr("foo", "a", "b")} xx {msgStr("bar")}<span>
-     *    === <span>Foo a b xx Bar {0}</span> (The substitution are only applied in the first message)
-     */
-    advancedMsg: (key: string, ...args: (string | undefined)[]) => JSX.Element;
-    /**
-     * See advancedMsg() but instead of returning a JSX.Element it returns a string.
+     * advancedMsgStr("${access-denied}") === advancedMsgStr("access-denied") === msgStr("access-denied") === "Access denied"
+     * advancedMsgStr("${not-a-message-key}") === advancedMsgStr("not-a-message-key") === "not-a-message-key"
      */
     advancedMsgStr: (key: string, ...args: (string | undefined)[]) => string;
 
@@ -85,10 +79,12 @@ export type GenericI18n<MessageKey extends string> = {
     isFetchingTranslations: boolean;
 };
 
-export function createGetI18n<ExtraMessageKey extends string = never>(messageBundle: {
-    [languageTag: string]: { [key in ExtraMessageKey]: string };
+export type MessageKey_defaultSet = keyof typeof messages_defaultSet_fallbackLanguage;
+
+export function createGetI18n<MessageKey_themeDefined extends string = never>(messagesByLanguageTag_themeDefined: {
+    [languageTag: string]: { [key in MessageKey_themeDefined]: string };
 }) {
-    type I18n = GenericI18n<MessageKey | ExtraMessageKey>;
+    type I18n = GenericI18n_noJsx<MessageKey_defaultSet | MessageKey_themeDefined>;
 
     type Result = { i18n: I18n; prI18n_currentLanguage: Promise<I18n> | undefined };
 
@@ -123,10 +119,18 @@ export function createGetI18n<ExtraMessageKey extends string = never>(messageBun
             labelBySupportedLanguageTag: Object.fromEntries((kcContext.locale?.supported ?? []).map(({ languageTag, label }) => [languageTag, label]))
         };
 
-        const { createI18nTranslationFunctions } = createI18nTranslationFunctionsFactory<MessageKey, ExtraMessageKey>({
-            messages_fallbackLanguage,
-            messageBundle_fallbackLanguage: messageBundle[fallbackLanguageTag],
-            messageBundle_currentLanguage: messageBundle[partialI18n.currentLanguageTag]
+        const { createI18nTranslationFunctions } = createI18nTranslationFunctionsFactory<MessageKey_themeDefined>({
+            messages_themeDefined:
+                messagesByLanguageTag_themeDefined[partialI18n.currentLanguageTag] ??
+                messagesByLanguageTag_themeDefined[fallbackLanguageTag] ??
+                (() => {
+                    const firstLanguageTag = Object.keys(messagesByLanguageTag_themeDefined)[0];
+                    if (firstLanguageTag === undefined) {
+                        return undefined;
+                    }
+                    return messagesByLanguageTag_themeDefined[firstLanguageTag];
+                })(),
+            messages_fromKcServer: kcContext["x-keycloakify"].messages
         });
 
         const isCurrentLanguageFallbackLanguage = partialI18n.currentLanguageTag === fallbackLanguageTag;
@@ -135,18 +139,18 @@ export function createGetI18n<ExtraMessageKey extends string = never>(messageBun
             i18n: {
                 ...partialI18n,
                 ...createI18nTranslationFunctions({
-                    messages_currentLanguage: isCurrentLanguageFallbackLanguage ? messages_fallbackLanguage : undefined
+                    messages_defaultSet_currentLanguage: isCurrentLanguageFallbackLanguage ? messages_defaultSet_fallbackLanguage : undefined
                 }),
                 isFetchingTranslations: !isCurrentLanguageFallbackLanguage
             },
             prI18n_currentLanguage: isCurrentLanguageFallbackLanguage
                 ? undefined
                 : (async () => {
-                      const messages_currentLanguage = await getMessages(partialI18n.currentLanguageTag);
+                      const messages_defaultSet_currentLanguage = await fetchMessages_defaultSet(partialI18n.currentLanguageTag);
 
                       const i18n_currentLanguage: I18n = {
                           ...partialI18n,
-                          ...createI18nTranslationFunctions({ messages_currentLanguage }),
+                          ...createI18nTranslationFunctions({ messages_defaultSet_currentLanguage }),
                           isFetchingTranslations: false
                       };
 
@@ -169,118 +173,76 @@ export function createGetI18n<ExtraMessageKey extends string = never>(messageBun
     return { getI18n };
 }
 
-function createI18nTranslationFunctionsFactory<MessageKey extends string, ExtraMessageKey extends string>(params: {
-    messages_fallbackLanguage: Record<MessageKey, string>;
-    messageBundle_fallbackLanguage: Record<ExtraMessageKey, string> | undefined;
-    messageBundle_currentLanguage: Partial<Record<ExtraMessageKey, string>> | undefined;
+function createI18nTranslationFunctionsFactory<MessageKey_themeDefined extends string>(params: {
+    messages_themeDefined: Record<MessageKey_themeDefined, string> | undefined;
+    messages_fromKcServer: Record<string, string>;
 }) {
-    const { messageBundle_currentLanguage } = params;
-
-    const messages_fallbackLanguage = {
-        ...params.messages_fallbackLanguage,
-        ...params.messageBundle_fallbackLanguage
-    };
+    const { messages_themeDefined, messages_fromKcServer } = params;
 
     function createI18nTranslationFunctions(params: {
-        messages_currentLanguage: Partial<Record<MessageKey, string>> | undefined;
-    }): Pick<GenericI18n<MessageKey | ExtraMessageKey>, "msg" | "msgStr" | "advancedMsg" | "advancedMsgStr"> {
-        const messages_currentLanguage = {
-            ...params.messages_currentLanguage,
-            ...messageBundle_currentLanguage
-        };
+        messages_defaultSet_currentLanguage: Partial<Record<MessageKey_defaultSet, string>> | undefined;
+    }): Pick<GenericI18n_noJsx<MessageKey_defaultSet | MessageKey_themeDefined>, "msgStr" | "advancedMsgStr"> {
+        const { messages_defaultSet_currentLanguage } = params;
 
-        function resolveMsg(props: { key: string; args: (string | undefined)[]; doRenderAsHtml: boolean }): string | JSX.Element | undefined {
-            const { key, args, doRenderAsHtml } = props;
+        function resolveMsg(props: { key: string; args: (string | undefined)[] }): string | undefined {
+            const { key, args } = props;
 
-            const messageOrUndefined: string | undefined = (messages_currentLanguage as any)[key] ?? (messages_fallbackLanguage as any)[key];
+            const message =
+                id<Record<string, string | undefined>>(messages_fromKcServer)[key] ??
+                id<Record<string, string | undefined> | undefined>(messages_themeDefined)?.[key] ??
+                id<Record<string, string | undefined> | undefined>(messages_defaultSet_currentLanguage)?.[key] ??
+                id<Record<string, string | undefined>>(messages_defaultSet_fallbackLanguage)[key];
 
-            if (messageOrUndefined === undefined) {
+            if (message === undefined) {
                 return undefined;
             }
 
-            const message = messageOrUndefined;
+            const startIndex = message
+                .match(/{[0-9]+}/g)
+                ?.map(g => g.match(/{([0-9]+)}/)![1])
+                .map(indexStr => parseInt(indexStr))
+                .sort((a, b) => a - b)[0];
 
-            const messageWithArgsInjectedIfAny = (() => {
-                const startIndex = message
-                    .match(/{[0-9]+}/g)
-                    ?.map(g => g.match(/{([0-9]+)}/)![1])
-                    .map(indexStr => parseInt(indexStr))
-                    .sort((a, b) => a - b)[0];
+            if (startIndex === undefined) {
+                // No {0} in message (no arguments expected)
+                return message;
+            }
 
-                if (startIndex === undefined) {
-                    // No {0} in message (no arguments expected)
-                    return message;
-                }
+            let messageWithArgsInjected = message;
 
-                let messageWithArgsInjected = message;
+            args.forEach((arg, i) => {
+                if (arg === undefined) {
+                    return;
+                }
 
-                args.forEach((arg, i) => {
-                    if (arg === undefined) {
-                        return;
-                    }
+                messageWithArgsInjected = messageWithArgsInjected.replace(
+                    new RegExp(`\\{${i + startIndex}\\}`, "g"),
+                    arg.replace(/</g, "&lt;").replace(/>/g, "&gt;")
+                );
+            });
 
-                    messageWithArgsInjected = messageWithArgsInjected.replace(
-                        new RegExp(`\\{${i + startIndex}\\}`, "g"),
-                        arg.replace(/</g, "&lt;").replace(/>/g, "&gt;")
-                    );
-                });
-
-                return messageWithArgsInjected;
-            })();
-
-            return doRenderAsHtml ? (
-                <span
-                    // NOTE: The message is trusted. The arguments are not but are escaped.
-                    dangerouslySetInnerHTML={{
-                        __html: messageWithArgsInjectedIfAny
-                    }}
-                />
-            ) : (
-                messageWithArgsInjectedIfAny
-            );
+            return messageWithArgsInjected;
         }
 
-        function resolveMsgAdvanced(props: { key: string; args: (string | undefined)[]; doRenderAsHtml: boolean }): JSX.Element | string {
-            const { key, args, doRenderAsHtml } = props;
+        function resolveMsgAdvanced(props: { key: string; args: (string | undefined)[] }): string {
+            const { key, args } = props;
 
-            if (!/\$\{[^}]+\}/.test(key)) {
-                const resolvedMessage = resolveMsg({ key, args, doRenderAsHtml });
-
-                if (resolvedMessage === undefined) {
-                    return doRenderAsHtml ? <span dangerouslySetInnerHTML={{ __html: key }} /> : key;
-                }
+            const match = key.match(/^\$\{(.+)\}$/);
 
-                return resolvedMessage;
+            if (match === null) {
+                return key;
             }
 
-            let isFirstMatch = true;
-
-            const resolvedComplexMessage = key.replace(/\$\{([^}]+)\}/g, (...[, key_i]) => {
-                const replaceBy = resolveMsg({ key: key_i, args: isFirstMatch ? args : [], doRenderAsHtml: false }) ?? key_i;
-
-                isFirstMatch = false;
-
-                return replaceBy;
-            });
-
-            return doRenderAsHtml ? <span dangerouslySetInnerHTML={{ __html: resolvedComplexMessage }} /> : resolvedComplexMessage;
+            return resolveMsg({ key: match[1], args }) ?? key;
         }
 
         return {
-            msgStr: (key, ...args) => resolveMsg({ key, args, doRenderAsHtml: false }) as string,
-            msg: (key, ...args) => resolveMsg({ key, args, doRenderAsHtml: true }) as JSX.Element,
-            advancedMsg: (key, ...args) =>
-                resolveMsgAdvanced({
-                    key,
-                    args,
-                    doRenderAsHtml: true
-                }) as JSX.Element,
-            advancedMsgStr: (key, ...args) =>
-                resolveMsgAdvanced({
-                    key,
-                    args,
-                    doRenderAsHtml: false
-                }) as string
+            msgStr: (key, ...args) => {
+                const resolvedMessage = resolveMsg({ key, args });
+                assert(resolvedMessage !== undefined, `Message with key "${key}" not found`);
+                return resolvedMessage;
+            },
+            advancedMsgStr: (key, ...args) => resolveMsgAdvanced({ key, args })
         };
     }
 

package/src/account/i18n/index.ts

@@ -1,4 +1,5 @@
-import type { GenericI18n, MessageKey, KcContextLike } from "./i18n";
-export type { MessageKey, KcContextLike };
-export type I18n = GenericI18n<MessageKey>;
+import type { GenericI18n } from "./GenericI18n";
+import type { MessageKey_defaultSet, KcContextLike } from "./i18n";
+export type { MessageKey_defaultSet, KcContextLike };
+export type I18n = GenericI18n<MessageKey_defaultSet>;
 export { createUseI18n } from "./useI18n";

package/src/account/i18n/{baseMessages → messages_defaultSet}/index.ts

@@ -2,8 +2,8 @@
 //PLEASE DO NOT EDIT MANUALLY
 import * as en from "./en";
 
-export async function getMessages(currentLanguageTag: string) {
-    const { default: messages } = await (() => {
+export async function fetchMessages_defaultSet(currentLanguageTag: string) {
+    const { default: messages_defaultSet } = await (() => {
         switch (currentLanguageTag) {
             case "en": return en;
             case "ar": return import("./ar");
@@ -35,5 +35,5 @@ export async function getMessages(currentLanguageTag: string) {
             default: return { "default": {} };
         }
     })();
-    return messages;
+    return messages_defaultSet;
 }

package/src/account/i18n/useI18n.tsx

@@ -0,0 +1,81 @@
+import { useEffect, useState } from "react";
+import { createGetI18n, type GenericI18n_noJsx, type KcContextLike, type MessageKey_defaultSet } from "./i18n";
+import { GenericI18n } from "./GenericI18n";
+import { Reflect } from "tsafe/Reflect";
+
+export function createUseI18n<MessageKey_themeDefined extends string = never>(messageBundle: {
+    [languageTag: string]: { [key in MessageKey_themeDefined]: string };
+}) {
+    type MessageKey = MessageKey_defaultSet | MessageKey_themeDefined;
+
+    type I18n = GenericI18n<MessageKey>;
+
+    const { withJsx } = (() => {
+        const cache = new WeakMap<GenericI18n_noJsx<MessageKey>, GenericI18n<MessageKey>>();
+
+        function renderHtmlString(htmlString: string): JSX.Element {
+            return (
+                <div
+                    style={{ display: "inline-block" }}
+                    dangerouslySetInnerHTML={{
+                        __html: htmlString
+                    }}
+                />
+            );
+        }
+
+        function withJsx(i18n_noJsx: GenericI18n_noJsx<MessageKey>): I18n {
+            use_cache: {
+                const i18n = cache.get(i18n_noJsx);
+
+                if (i18n === undefined) {
+                    break use_cache;
+                }
+
+                return i18n;
+            }
+
+            const i18n: I18n = {
+                ...i18n_noJsx,
+                msg: (...args) => renderHtmlString(i18n_noJsx.msgStr(...args)),
+                advancedMsg: (...args) => renderHtmlString(i18n_noJsx.advancedMsgStr(...args))
+            };
+
+            cache.set(i18n_noJsx, i18n);
+
+            return i18n;
+        }
+
+        return { withJsx };
+    })();
+
+    const { getI18n } = createGetI18n(messageBundle);
+
+    function useI18n(params: { kcContext: KcContextLike }): { i18n: I18n } {
+        const { kcContext } = params;
+
+        const { i18n, prI18n_currentLanguage } = getI18n({ kcContext });
+
+        const [i18n_toReturn, setI18n_toReturn] = useState<I18n>(withJsx(i18n));
+
+        useEffect(() => {
+            let isActive = true;
+
+            prI18n_currentLanguage?.then(i18n => {
+                if (!isActive) {
+                    return;
+                }
+
+                setI18n_toReturn(withJsx(i18n));
+            });
+
+            return () => {
+                isActive = false;
+            };
+        }, []);
+
+        return { i18n: i18n_toReturn };
+    }
+
+    return { useI18n, ofTypeI18n: Reflect<I18n>() };
+}

package/src/bin/keycloakify/generateFtl/kcContextDeclarationTemplate.ftl

@@ -1,6 +1,24 @@
 <#assign pageId="PAGE_ID_xIgLsPgGId9D8e">
 <#assign themeType="KEYCLOAKIFY_THEME_TYPE_dExKd3xEdr">
+<#assign xKeycloakifyMessages = {}>
+<#assign debugMessage="">
+
 const kcContext = ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
+
+<@addNonAutomaticallyGatherableMessagesToXKeycloakifyMessages />
+
+console.log(`${debugMessage}`);
+
+kcContext["x-keycloakify"] = {};
+
+{
+  var messages = {};
+  <#list xKeycloakifyMessages as key, resolvedMsg>
+    messages["${key}"] = decodeHtmlEntities("${resolvedMsg?js_string}");
+  </#list>
+  kcContext["x-keycloakify"].messages = messages;
+}
+
 if( kcContext.messagesPerField ){
     var existsError_singleFieldName = kcContext.messagesPerField.existsError;
     kcContext.messagesPerField.existsError = function (){
@@ -42,85 +60,7 @@ if( kcContext.resourceUrl && !kcContext.url ){
         enumerable: false
     });
 }
-kcContext["x-keycloakify"] = {
-    messages: {}
-};
-<#if profile?? && profile.attributes??>
-    {
-        var messages = {
-            <#list profile.attributes as attribute>
-                <#if attribute.displayName??>
-                    "${attribute.displayName}": decodeHtmlEntities("${advancedMsg(attribute.displayName)?js_string}"),
-                </#if>
-                <#if attribute.annotations??>
-                    <#if attribute.annotations.inputHelperTextBefore??>
-                        "${attribute.annotations.inputHelperTextBefore}": decodeHtmlEntities("${advancedMsg(attribute.annotations.inputHelperTextBefore)?js_string}"),
-                    </#if>
-                    <#if attribute.annotations.inputHelperTextAfter??>
-                        "${attribute.annotations.inputHelperTextAfter}": decodeHtmlEntities("${advancedMsg(attribute.annotations.inputHelperTextAfter)?js_string}"),
-                    </#if>
-                    <#if attribute.annotations.inputTypePlaceholder??>
-                        "${attribute.annotations.inputTypePlaceholder}": decodeHtmlEntities("${advancedMsg(attribute.annotations.inputTypePlaceholder)?js_string}"),
-                    </#if>
-                    <!-- Loop through the options that are in attribute.validators.options.options -->
-                    <#if (
-                        attribute.annotations.inputOptionLabelsI18nPrefix?? &&
-                        attribute.validators?? &&
-                        attribute.validators.options??
-                    )>
-                        <#list attribute.validators.options.options as option>
-                            "${attribute.annotations.inputOptionLabelsI18nPrefix}.${option}": decodeHtmlEntities("${msg(attribute.annotations.inputOptionLabelsI18nPrefix + "." + option)?js_string}"),
-                        </#list>
-                    </#if>
-                </#if>
-            </#list>
-        };
-        Object.assign(kcContext["x-keycloakify"].messages, messages);
-    }
-</#if>
-<#if pageId == "terms.ftl" || termsAcceptanceRequired?? && termsAcceptanceRequired>
-    kcContext["x-keycloakify"].messages["termsText"]= decodeHtmlEntities("${msg("termsText")?js_string}");
-</#if>
-<#if auth?? && auth.authenticationSelections??>
-    {
-        var messages = {
-            <#list auth.authenticationSelections as authenticationSelection>
-                <#if authenticationSelection.displayName??>
-                    "${authenticationSelection.displayName}": decodeHtmlEntities("${advancedMsg(authenticationSelection.displayName)?js_string}"),
-                </#if>
-                <#if authenticationSelection.helpText??>
-                    "${authenticationSelection.helpText}": decodeHtmlEntities("${advancedMsg(authenticationSelection.helpText)?js_string}"),
-                </#if>
-            </#list>
-        };
-        Object.assign(kcContext["x-keycloakify"].messages, messages);
-    }
-</#if>
-<#if themeType == "login" && pageId == "info.ftl" && requiredActions??>
-    {
-        var messages = {
-            <#list requiredActions as requiredAction>
-                "requiredAction.${requiredAction}": decodeHtmlEntities("${advancedMsg("requiredAction." + requiredAction)?js_string}"),
-            </#list>
-        };
-        Object.assign(kcContext["x-keycloakify"].messages, messages);
-    }
-</#if>
-<#if authenticators?? && authenticators.authenticators??>
-    {
-        var messages = {
-            <#list authenticators.authenticators as authenticator>
-                "${authenticator.label}": decodeHtmlEntities("${advancedMsg(authenticator.label)?js_string}"),
-                <#if authenticator.transports?? && authenticator.transports.displayNameProperties??>
-                    <#list authenticator.transports.displayNameProperties as displayNameProperty>
-                        "${displayNameProperty}": decodeHtmlEntities("${advancedMsg(displayNameProperty)?js_string}"),
-                    </#list>
-                </#if>
-            </#list>
-        };
-        Object.assign(kcContext["x-keycloakify"].messages, messages);
-    }
-</#if>
+
 attributes_to_attributesByName: {
     if( !kcContext.profile ){
         break attributes_to_attributesByName;
@@ -128,7 +68,7 @@ attributes_to_attributesByName: {
     if( !kcContext.profile.attributes ){
         break attributes_to_attributesByName;
     }
-    var attributes =  kcContext.profile.attributes;
+    var attributes = kcContext.profile.attributes;
     delete kcContext.profile.attributes;
     kcContext.profile.attributesByName = {};
     attributes.forEach(function(attribute){
@@ -571,6 +511,17 @@ function decodeHtmlEntities(htmlStr){
             <#return object?c>
         </#if>
 
+        <#local isString = "">
+        <#attempt>
+            <#local isString = object?is_string>
+        <#recover>
+            <#return "ABORT: Can't test if it's a string">
+        </#attempt>
+
+        <#if isString>
+            <@addToXKeycloakifyMessagesIfMessageKey str=object />
+        </#if>
+
         <#attempt>
             <#return '"' + object?js_string + '"'>;
         <#recover>
@@ -621,4 +572,73 @@ function decodeHtmlEntities(htmlStr){
 
 <#function are_same_path path searchedPath>
     <#return path?size == searchedPath?size && is_subpath(path, searchedPath)>
-</#function>
+</#function>
+
+<#macro addToXKeycloakifyMessagesIfMessageKey str>
+    <#if !msg?? || !msg?is_method>
+        <#return>
+    </#if>
+    <#if (str?length > 200)>
+        <#return>
+    </#if>
+    <#local key=removeBrackets(str)>
+    <#if key?length==0>
+        <#return>
+    </#if>
+    <#if !(key?matches(r"^[a-zA-Z0-9-_.]*$"))>
+        <#return>
+    </#if>
+    <#local resolvedMsg=msg(key)>
+    <#if resolvedMsg==key>
+        <#return>
+    </#if>
+    <#assign xKeycloakifyMessages = xKeycloakifyMessages + { "${key}": resolvedMsg }>
+</#macro>
+
+<#function removeBrackets str>
+  <#if str?starts_with("${") && str?ends_with("}")>
+    <#return str[2..(str?length-2)]>
+  <#else>
+    <#return str>
+  </#if>
+</#function>
+
+<#macro addNonAutomaticallyGatherableMessagesToXKeycloakifyMessages>
+    <#if profile?? && profile?is_hash && profile.attributes?? && profile.attributes?is_enumerable>
+        <#list profile.attributes as attribute>
+            <#if !(
+                attribute.annotations?? && attribute.annotations?is_hash &&
+                attribute.annotations.inputOptionLabelsI18nPrefix?? && attribute.annotations.inputOptionLabelsI18nPrefix?is_string
+            )>
+                <#continue>
+            </#if>
+            <#local prefix=attribute.annotations.inputOptionLabelsI18nPrefix>
+            <#if !(
+                attribute.validators?? && attribute.validators?is_hash &&
+                attribute.validators.options?? && attribute.validators.options?is_hash &&
+                attribute.validators.options.options?? && attribute.validators.options.options?is_enumerable
+            )>
+                <#continue>
+            </#if>
+            <#list attribute.validators.options.options as option>
+                <#if !option?is_string>
+                    <#continue>
+                </#if>
+                <@addToXKeycloakifyMessagesIfMessageKey str="${prefix}.${option}" />
+            </#list>
+        </#list>
+    </#if>
+    <#if pageId == "terms.ftl" || termsAcceptanceRequired?? && termsAcceptanceRequired>
+        <@addToXKeycloakifyMessagesIfMessageKey str="termsText" />
+    </#if>
+    <#if requiredActions?? && requiredActions?is_enumerable>
+        <#list requiredActions as requiredAction>
+            <#if !requiredAction?is_string>
+                <#continue>
+            </#if>
+            <@addToXKeycloakifyMessagesIfMessageKey str="requiredAction.${requiredAction}" />
+        </#list>
+    </#if>
+</#macro>
+
+

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

@@ -22,7 +22,7 @@ export function generateMessageProperties(params: {
         "src",
         themeType,
         "i18n",
-        "baseMessages"
+        "messages_defaultSet"
     );
 
     const baseMessageBundle: { [languageTag: string]: Record<string, string> } =