keycloakify 10.0.0-rc.12 → 10.0.0-rc.120

package/src/bin/keycloakify/buildJars/buildJar.ts

@@ -1,88 +1,144 @@
 import { assert, type Equals } from "tsafe/assert";
-import type { KeycloakAccountV1Version, KeycloakThemeAdditionalInfoExtensionVersion } from "./extensionVersions";
+import type {
+    KeycloakAccountV1Version,
+    KeycloakThemeAdditionalInfoExtensionVersion
+} from "./extensionVersions";
 import { join as pathJoin, dirname as pathDirname } from "path";
 import { transformCodebase } from "../../tools/transformCodebase";
-import type { BuildOptions } from "../../shared/buildOptions";
+import type { BuildContext } from "../../shared/buildContext";
 import * as fs from "fs/promises";
-import { accountV1ThemeName } from "../../shared/constants";
-import { generatePom, BuildOptionsLike as BuildOptionsLike_generatePom } from "./generatePom";
+import { ACCOUNT_V1_THEME_NAME } from "../../shared/constants";
+import {
+    generatePom,
+    BuildContextLike as BuildContextLike_generatePom
+} from "./generatePom";
 import { readFileSync } from "fs";
 import { isInside } from "../../tools/isInside";
 import child_process from "child_process";
 import { rmSync } from "../../tools/fs.rmSync";
-import { getMetaInfKeycloakThemesJsonPath } from "../../shared/metaInfKeycloakThemes";
+import { writeMetaInfKeycloakThemes } from "../../shared/metaInfKeycloakThemes";
 
-export type BuildOptionsLike = BuildOptionsLike_generatePom & {
+export type BuildContextLike = BuildContextLike_generatePom & {
     keycloakifyBuildDirPath: string;
     themeNames: string[];
     artifactId: string;
     themeVersion: string;
     cacheDirPath: string;
+    implementedThemeTypes: BuildContext["implementedThemeTypes"];
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
 export async function buildJar(params: {
     jarFileBasename: string;
     keycloakAccountV1Version: KeycloakAccountV1Version;
     keycloakThemeAdditionalInfoExtensionVersion: KeycloakThemeAdditionalInfoExtensionVersion;
-    buildOptions: BuildOptionsLike;
+    resourcesDirPath: string;
+    doesImplementAccountV1Theme: boolean;
+    buildContext: BuildContextLike;
 }): Promise<void> {
-    const { jarFileBasename, keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, buildOptions } = params;
-
-    const keycloakifyBuildTmpDirPath = pathJoin(buildOptions.cacheDirPath, jarFileBasename.replace(".jar", ""));
-
-    rmSync(keycloakifyBuildTmpDirPath, { "recursive": true, "force": true });
-
-    {
-        const keycloakThemesJsonFilePath = getMetaInfKeycloakThemesJsonPath({ "keycloakifyBuildDirPath": "" });
+    const {
+        jarFileBasename,
+        keycloakAccountV1Version,
+        keycloakThemeAdditionalInfoExtensionVersion,
+        resourcesDirPath,
+        doesImplementAccountV1Theme,
+        buildContext
+    } = params;
+
+    const keycloakifyBuildCacheDirPath = pathJoin(
+        buildContext.cacheDirPath,
+        "maven",
+        jarFileBasename.replace(".jar", "")
+    );
 
-        const themePropertiesFilePathSet = new Set(
-            ...buildOptions.themeNames.map(themeName => pathJoin("src", "main", "resources", "theme", themeName, "account", "theme.properties"))
-        );
+    const tmpResourcesDirPath = pathJoin(
+        keycloakifyBuildCacheDirPath,
+        "src",
+        "main",
+        "resources"
+    );
 
-        const accountV1RelativeDirPath = pathJoin("src", "main", "resources", "theme", accountV1ThemeName);
+    rmSync(tmpResourcesDirPath, { recursive: true, force: true });
+
+    transformCodebase({
+        srcDirPath: resourcesDirPath,
+        destDirPath: tmpResourcesDirPath,
+        transformSourceCode:
+            !doesImplementAccountV1Theme || keycloakAccountV1Version !== null
+                ? undefined
+                : (params: {
+                      fileRelativePath: string;
+                      sourceCode: Buffer;
+                  }): { modifiedSourceCode: Buffer } | undefined => {
+                      const { fileRelativePath, sourceCode } = params;
+
+                      if (
+                          isInside({
+                              dirPath: pathJoin("theme", ACCOUNT_V1_THEME_NAME),
+                              filePath: fileRelativePath
+                          })
+                      ) {
+                          return undefined;
+                      }
 
-        transformCodebase({
-            "srcDirPath": buildOptions.keycloakifyBuildDirPath,
-            "destDirPath": keycloakifyBuildTmpDirPath,
-            "transformSourceCode":
-                keycloakAccountV1Version !== null
-                    ? undefined
-                    : ({ fileRelativePath, sourceCode }) => {
-                          if (fileRelativePath === keycloakThemesJsonFilePath) {
-                              const keycloakThemesJsonParsed = JSON.parse(sourceCode.toString("utf8")) as {
-                                  themes: { name: string; types: string[] }[];
-                              };
+                      for (const themeName of buildContext.themeNames) {
+                          if (
+                              fileRelativePath ===
+                              pathJoin("theme", themeName, "account", "theme.properties")
+                          ) {
+                              const modifiedSourceCode = Buffer.from(
+                                  sourceCode
+                                      .toString("utf8")
+                                      .replace(
+                                          `parent=${ACCOUNT_V1_THEME_NAME}`,
+                                          "parent=keycloak"
+                                      ),
+                                  "utf8"
+                              );
+
+                              assert(
+                                  Buffer.compare(modifiedSourceCode, sourceCode) !== 0
+                              );
+
+                              return { modifiedSourceCode };
+                          }
+                      }
 
-                              keycloakThemesJsonParsed.themes = keycloakThemesJsonParsed.themes.filter(({ name }) => name !== accountV1ThemeName);
+                      return { modifiedSourceCode: sourceCode };
+                  }
+    });
 
-                              return { "modifiedSourceCode": Buffer.from(JSON.stringify(keycloakThemesJsonParsed, null, 2), "utf8") };
-                          }
+    remove_account_v1_in_meta_inf: {
+        if (!doesImplementAccountV1Theme) {
+            // NOTE: We do not have account v1 anyway
+            break remove_account_v1_in_meta_inf;
+        }
 
-                          if (isInside({ "dirPath": "target", "filePath": fileRelativePath })) {
-                              return undefined;
-                          }
+        if (keycloakAccountV1Version !== null) {
+            // NOTE: No, we need to keep account-v1 in meta-inf
+            break remove_account_v1_in_meta_inf;
+        }
 
-                          if (isInside({ "dirPath": accountV1RelativeDirPath, "filePath": fileRelativePath })) {
-                              return undefined;
-                          }
+        writeMetaInfKeycloakThemes({
+            resourcesDirPath: tmpResourcesDirPath,
+            getNewMetaInfKeycloakTheme: ({ metaInfKeycloakTheme }) => {
+                assert(metaInfKeycloakTheme !== undefined);
 
-                          if (themePropertiesFilePathSet.has(fileRelativePath)) {
-                              return {
-                                  "modifiedSourceCode": Buffer.from(
-                                      sourceCode.toString("utf8").replace(`parent=${accountV1ThemeName}`, "parent=keycloak"),
-                                      "utf8"
-                                  )
-                              };
-                          }
+                metaInfKeycloakTheme.themes = metaInfKeycloakTheme.themes.filter(
+                    ({ name }) => name !== ACCOUNT_V1_THEME_NAME
+                );
 
-                          return { "modifiedSourceCode": sourceCode };
-                      }
+                return metaInfKeycloakTheme;
+            }
         });
     }
 
     route_legacy_pages: {
+        if (!buildContext.implementedThemeTypes.login.isImplemented) {
+            break route_legacy_pages;
+        }
+
         // NOTE: If there's no account theme there is no special target for keycloak 24 and up so we create
         // the pages anyway. If there is an account pages, since we know that account-v1 is only support keycloak
         // 24 in version 0.4 and up, we can safely break the route for legacy pages.
@@ -97,17 +153,24 @@ export async function buildJar(params: {
             }
         })();
 
+        // TODO: Remove this optimization, it's a bit hacky.
         if (doBreak) {
             break route_legacy_pages;
         }
 
         (["register.ftl", "login-update-profile.ftl"] as const).forEach(pageId =>
-            buildOptions.themeNames.map(themeName => {
-                const ftlFilePath = pathJoin(keycloakifyBuildTmpDirPath, "src", "main", "resources", "theme", themeName, "login", pageId);
+            buildContext.themeNames.map(themeName => {
+                const ftlFilePath = pathJoin(
+                    tmpResourcesDirPath,
+                    "theme",
+                    themeName,
+                    "login",
+                    pageId
+                );
 
                 const ftlFileContent = readFileSync(ftlFilePath).toString("utf8");
 
-                const realPageId = (() => {
+                const ftlFileBasename = (() => {
                     switch (pageId) {
                         case "register.ftl":
                             return "register-user-profile.ftl";
@@ -118,53 +181,65 @@ export async function buildJar(params: {
                 })();
 
                 const modifiedFtlFileContent = ftlFileContent.replace(
-                    `out["pageId"] = "\${pageId}";`,
-                    `out["pageId"] = "${pageId}"; out["realPageId"] = "${realPageId}";`
+                    `"ftlTemplateFileName": "${pageId}"`,
+                    `"ftlTemplateFileName": "${ftlFileBasename}"`
                 );
 
                 assert(modifiedFtlFileContent !== ftlFileContent);
 
-                fs.writeFile(pathJoin(pathDirname(ftlFilePath), realPageId), Buffer.from(modifiedFtlFileContent, "utf8"));
+                fs.writeFile(
+                    pathJoin(pathDirname(ftlFilePath), ftlFileBasename),
+                    Buffer.from(modifiedFtlFileContent, "utf8")
+                );
             })
         );
     }
 
     {
         const { pomFileCode } = generatePom({
-            buildOptions,
+            buildContext,
             keycloakAccountV1Version,
             keycloakThemeAdditionalInfoExtensionVersion
         });
 
-        await fs.writeFile(pathJoin(keycloakifyBuildTmpDirPath, "pom.xml"), Buffer.from(pomFileCode, "utf8"));
+        await fs.writeFile(
+            pathJoin(keycloakifyBuildCacheDirPath, "pom.xml"),
+            Buffer.from(pomFileCode, "utf8")
+        );
     }
 
     await new Promise<void>((resolve, reject) =>
-        child_process.exec("mvn clean install", { "cwd": keycloakifyBuildTmpDirPath }, error => {
-            if (error !== null) {
-                console.error(
-                    `Build jar failed: ${JSON.stringify(
-                        {
-                            jarFileBasename,
-                            keycloakAccountV1Version,
-                            keycloakThemeAdditionalInfoExtensionVersion
-                        },
-                        null,
-                        2
-                    )}`
-                );
-
-                reject(error);
-                return;
+        child_process.exec(
+            `mvn install -Dmaven.repo.local="${pathJoin(keycloakifyBuildCacheDirPath, ".m2")}"`,
+            { cwd: keycloakifyBuildCacheDirPath },
+            error => {
+                if (error !== null) {
+                    console.error(
+                        `Build jar failed: ${JSON.stringify(
+                            {
+                                jarFileBasename,
+                                keycloakAccountV1Version,
+                                keycloakThemeAdditionalInfoExtensionVersion
+                            },
+                            null,
+                            2
+                        )}`
+                    );
+
+                    reject(error);
+                    return;
+                }
+                resolve();
             }
-            resolve();
-        })
+        )
     );
 
     await fs.rename(
-        pathJoin(keycloakifyBuildTmpDirPath, "target", `${buildOptions.artifactId}-${buildOptions.themeVersion}.jar`),
-        pathJoin(buildOptions.keycloakifyBuildDirPath, jarFileBasename)
+        pathJoin(
+            keycloakifyBuildCacheDirPath,
+            "target",
+            `${buildContext.artifactId}-${buildContext.themeVersion}.jar`
+        ),
+        pathJoin(buildContext.keycloakifyBuildDirPath, jarFileBasename)
     );
-
-    rmSync(keycloakifyBuildTmpDirPath, { "recursive": true });
 }

package/src/bin/keycloakify/buildJars/buildJars.ts

@@ -1,33 +1,38 @@
 import { assert } from "tsafe/assert";
-import { exclude } from "tsafe/exclude";
-import { keycloakAccountV1Versions, keycloakThemeAdditionalInfoExtensionVersions } from "./extensionVersions";
+import {
+    keycloakAccountV1Versions,
+    keycloakThemeAdditionalInfoExtensionVersions
+} from "./extensionVersions";
 import { getKeycloakVersionRangeForJar } from "./getKeycloakVersionRangeForJar";
-import { buildJar, BuildOptionsLike as BuildOptionsLike_buildJar } from "./buildJar";
-import type { BuildOptions } from "../../shared/buildOptions";
-import { getJarFileBasename } from "../../shared/getJarFileBasename";
-import { readMetaInfKeycloakThemes } from "../../shared/metaInfKeycloakThemes";
-import { accountV1ThemeName } from "../../shared/constants";
+import { buildJar, BuildContextLike as BuildContextLike_buildJar } from "./buildJar";
+import type { BuildContext } from "../../shared/buildContext";
 
-export type BuildOptionsLike = BuildOptionsLike_buildJar & {
+export type BuildContextLike = BuildContextLike_buildJar & {
+    projectDirPath: string;
     keycloakifyBuildDirPath: string;
+    implementedThemeTypes: BuildContext["implementedThemeTypes"];
+    jarTargets: BuildContext["jarTargets"];
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
-export async function buildJars(params: { buildOptions: BuildOptionsLike }): Promise<void> {
-    const { buildOptions } = params;
+export async function buildJars(params: {
+    resourcesDirPath: string;
+    buildContext: BuildContextLike;
+}): Promise<void> {
+    const { resourcesDirPath, buildContext } = params;
 
-    const doesImplementAccountTheme = readMetaInfKeycloakThemes({
-        "keycloakifyBuildDirPath": buildOptions.keycloakifyBuildDirPath
-    }).themes.some(({ name }) => name === accountV1ThemeName);
+    const doesImplementAccountV1Theme =
+        buildContext.implementedThemeTypes.account.isImplemented &&
+        buildContext.implementedThemeTypes.account.type === "Multi-Page";
 
     await Promise.all(
         keycloakAccountV1Versions
             .map(keycloakAccountV1Version =>
-                keycloakThemeAdditionalInfoExtensionVersions
-                    .map(keycloakThemeAdditionalInfoExtensionVersion => {
+                keycloakThemeAdditionalInfoExtensionVersions.map(
+                    keycloakThemeAdditionalInfoExtensionVersion => {
                         const keycloakVersionRange = getKeycloakVersionRangeForJar({
-                            doesImplementAccountTheme,
+                            doesImplementAccountV1Theme,
                             keycloakAccountV1Version,
                             keycloakThemeAdditionalInfoExtensionVersion
                         });
@@ -36,25 +41,27 @@ export async function buildJars(params: { buildOptions: BuildOptionsLike }): Pro
                             return undefined;
                         }
 
-                        return { keycloakThemeAdditionalInfoExtensionVersion, keycloakVersionRange };
-                    })
-                    .filter(exclude(undefined))
-                    .map(({ keycloakThemeAdditionalInfoExtensionVersion, keycloakVersionRange }) => {
-                        const { jarFileBasename } = getJarFileBasename({ keycloakVersionRange });
+                        const jarTarget = buildContext.jarTargets.find(
+                            jarTarget =>
+                                jarTarget.keycloakVersionRange === keycloakVersionRange
+                        );
 
-                        return {
-                            keycloakThemeAdditionalInfoExtensionVersion,
-                            jarFileBasename
-                        };
-                    })
-                    .map(({ keycloakThemeAdditionalInfoExtensionVersion, jarFileBasename }) =>
-                        buildJar({
+                        if (jarTarget === undefined) {
+                            return undefined;
+                        }
+
+                        const { jarFileBasename } = jarTarget;
+
+                        return buildJar({
                             jarFileBasename,
                             keycloakAccountV1Version,
                             keycloakThemeAdditionalInfoExtensionVersion,
-                            buildOptions
-                        })
-                    )
+                            resourcesDirPath,
+                            doesImplementAccountV1Theme,
+                            buildContext
+                        });
+                    }
+                )
             )
             .flat()
     );

package/src/bin/keycloakify/buildJars/extensionVersions.ts

@@ -1,5 +1,5 @@
 // NOTE: v0.5 is a dummy version.
-export const keycloakAccountV1Versions = [null, "0.3", "0.4"] as const;
+export const keycloakAccountV1Versions = [null, "0.3", "0.4", "0.6"] as const;
 
 /**
  * https://central.sonatype.com/artifact/io.phasetwo.keycloak/keycloak-account-v1
@@ -13,4 +13,5 @@ export const keycloakThemeAdditionalInfoExtensionVersions = [null, "1.1.5"] as c
  * https://central.sonatype.com/artifact/dev.jcputney/keycloak-theme-additional-info-extension
  * https://github.com/jcputney/keycloak-theme-additional-info-extension
  * */
-export type KeycloakThemeAdditionalInfoExtensionVersion = (typeof keycloakThemeAdditionalInfoExtensionVersions)[number];
+export type KeycloakThemeAdditionalInfoExtensionVersion =
+    (typeof keycloakThemeAdditionalInfoExtensionVersions)[number];

package/src/bin/keycloakify/buildJars/generatePom.ts

@@ -1,21 +1,28 @@
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "../../shared/buildOptions";
-import type { KeycloakAccountV1Version, KeycloakThemeAdditionalInfoExtensionVersion } from "./extensionVersions";
+import type { BuildContext } from "../../shared/buildContext";
+import type {
+    KeycloakAccountV1Version,
+    KeycloakThemeAdditionalInfoExtensionVersion
+} from "./extensionVersions";
 
-export type BuildOptionsLike = {
+export type BuildContextLike = {
     groupId: string;
     artifactId: string;
     themeVersion: string;
 };
 
-assert<BuildOptions extends BuildOptionsLike ? true : false>();
+assert<BuildContext extends BuildContextLike ? true : false>();
 
 export function generatePom(params: {
     keycloakAccountV1Version: KeycloakAccountV1Version;
     keycloakThemeAdditionalInfoExtensionVersion: KeycloakThemeAdditionalInfoExtensionVersion;
-    buildOptions: BuildOptionsLike;
+    buildContext: BuildContextLike;
 }) {
-    const { keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, buildOptions } = params;
+    const {
+        keycloakAccountV1Version,
+        keycloakThemeAdditionalInfoExtensionVersion,
+        buildContext
+    } = params;
 
     const { pomFileCode } = (function generatePomFileCode(): {
         pomFileCode: string;
@@ -26,16 +33,17 @@ export function generatePom(params: {
             `	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"`,
             `	 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">`,
             `  <modelVersion>4.0.0</modelVersion>`,
-            `	<groupId>${buildOptions.groupId}</groupId>`,
-            `	<artifactId>${buildOptions.artifactId}</artifactId>`,
-            `	<version>${buildOptions.themeVersion}</version>`,
-            `	<name>${buildOptions.artifactId}</name>`,
+            `	<groupId>${buildContext.groupId}</groupId>`,
+            `	<artifactId>${buildContext.artifactId}</artifactId>`,
+            `	<version>${buildContext.themeVersion}</version>`,
+            `	<name>${buildContext.artifactId}</name>`,
             `  <description />`,
             `  <packaging>jar</packaging>`,
             `  <properties>`,
             `    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>`,
             `  </properties>`,
-            ...(keycloakAccountV1Version !== null && keycloakThemeAdditionalInfoExtensionVersion !== null
+            ...(keycloakAccountV1Version !== null ||
+            keycloakThemeAdditionalInfoExtensionVersion !== null
                 ? [
                       `  <build>`,
                       `    <plugins>`,

package/src/bin/keycloakify/buildJars/getKeycloakVersionRangeForJar.ts

@@ -1,15 +1,22 @@
 import { assert, type Equals } from "tsafe/assert";
-import type { KeycloakAccountV1Version, KeycloakThemeAdditionalInfoExtensionVersion } from "./extensionVersions";
+import type {
+    KeycloakAccountV1Version,
+    KeycloakThemeAdditionalInfoExtensionVersion
+} from "./extensionVersions";
 import type { KeycloakVersionRange } from "../../shared/KeycloakVersionRange";
 
 export function getKeycloakVersionRangeForJar(params: {
-    doesImplementAccountTheme: boolean;
+    doesImplementAccountV1Theme: boolean;
     keycloakAccountV1Version: KeycloakAccountV1Version;
     keycloakThemeAdditionalInfoExtensionVersion: KeycloakThemeAdditionalInfoExtensionVersion;
 }): KeycloakVersionRange | undefined {
-    const { keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, doesImplementAccountTheme } = params;
+    const {
+        keycloakAccountV1Version,
+        keycloakThemeAdditionalInfoExtensionVersion,
+        doesImplementAccountV1Theme
+    } = params;
 
-    if (doesImplementAccountTheme) {
+    if (doesImplementAccountV1Theme) {
         const keycloakVersionRange = (() => {
             switch (keycloakAccountV1Version) {
                 case null:
@@ -19,7 +26,9 @@ export function getKeycloakVersionRangeForJar(params: {
                         case "1.1.5":
                             return undefined;
                     }
-                    assert<Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>>(false);
+                    assert<
+                        Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>
+                    >(false);
                 case "0.3":
                     switch (keycloakThemeAdditionalInfoExtensionVersion) {
                         case null:
@@ -27,19 +36,36 @@ export function getKeycloakVersionRangeForJar(params: {
                         case "1.1.5":
                             return "23" as const;
                     }
-                    assert<Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>>(false);
+                    assert<
+                        Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>
+                    >(false);
                 case "0.4":
                     switch (keycloakThemeAdditionalInfoExtensionVersion) {
                         case null:
                             return undefined;
                         case "1.1.5":
-                            return "24-and-above" as const;
+                            return "24" as const;
+                    }
+                    assert<
+                        Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>
+                    >(false);
+                case "0.6":
+                    switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                        case null:
+                            return undefined;
+                        case "1.1.5":
+                            return "25-and-above" as const;
                     }
-                    assert<Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>>(false);
             }
+            assert<Equals<typeof keycloakAccountV1Version, never>>(false);
         })();
 
-        assert<Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithAccountTheme | undefined>>();
+        assert<
+            Equals<
+                typeof keycloakVersionRange,
+                KeycloakVersionRange.WithAccountV1Theme | undefined
+            >
+        >();
 
         return keycloakVersionRange;
     } else {
@@ -47,17 +73,23 @@ export function getKeycloakVersionRangeForJar(params: {
             if (keycloakAccountV1Version !== null) {
                 return undefined;
             }
-
             switch (keycloakThemeAdditionalInfoExtensionVersion) {
                 case null:
                     return "21-and-below";
                 case "1.1.5":
                     return "22-and-above";
             }
-            assert<Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>>(false);
+            assert<Equals<typeof keycloakThemeAdditionalInfoExtensionVersion, never>>(
+                false
+            );
         })();
 
-        assert<Equals<typeof keycloakVersionRange, KeycloakVersionRange.WithoutAccountTheme | undefined>>();
+        assert<
+            Equals<
+                typeof keycloakVersionRange,
+                KeycloakVersionRange.WithoutAccountV1Theme | undefined
+            >
+        >();
 
         return keycloakVersionRange;
     }