keycloakify 8.0.0-rc.3 → 9.0.0-rc.0

package/src/bin/keycloakify/generateTheme/generateTheme.ts

@@ -1,13 +1,13 @@
 import { transformCodebase } from "../../tools/transformCodebase";
 import * as fs from "fs";
-import { join as pathJoin } from "path";
+import { join as pathJoin, basename as pathBasename, resolve as pathResolve } from "path";
 import { replaceImportsFromStaticInJsCode } from "../replacers/replaceImportsFromStaticInJsCode";
 import { replaceImportsInCssCode } from "../replacers/replaceImportsInCssCode";
-import { generateFtlFilesCodeFactory, loginThemePageIds, accountThemePageIds, themeTypes, type ThemeType } from "../generateFtl";
-import { basenameOfKeycloakDirInPublicDir } from "../../mockTestingResourcesPath";
+import { generateFtlFilesCodeFactory, loginThemePageIds, accountThemePageIds } from "../generateFtl";
+import { themeTypes, type ThemeType, lastKeycloakVersionWithAccountV1, keycloak_resources, retrocompatPostfix, accountV1 } from "../../constants";
 import { isInside } from "../../tools/isInside";
 import type { BuildOptions } from "../BuildOptions";
-import { assert } from "tsafe/assert";
+import { assert, type Equals } from "tsafe/assert";
 import { downloadKeycloakStaticResources } from "./downloadKeycloakStaticResources";
 import { readFieldNameUsage } from "./readFieldNameUsage";
 import { readExtraPagesNames } from "./readExtraPageNames";
@@ -15,36 +15,39 @@ import { generateMessageProperties } from "./generateMessageProperties";
 import { readStaticResourcesUsage } from "./readStaticResourcesUsage";
 
 export type BuildOptionsLike = {
-    themeName: string;
     extraThemeProperties: string[] | undefined;
     themeVersion: string;
-    keycloakVersionDefaultAssets: string;
+    loginThemeResourcesFromKeycloakVersion: string;
     urlPathname: string | undefined;
+    keycloakifyBuildDirPath: string;
+    reactAppBuildDirPath: string;
+    cacheDirPath: string;
+    doBuildRetrocompatAccountTheme: boolean;
 };
 
 assert<BuildOptions extends BuildOptionsLike ? true : false>();
 
 export async function generateTheme(params: {
-    projectDirPath: string;
-    reactAppBuildDirPath: string;
-    keycloakThemeBuildingDirPath: string;
+    themeName: string;
     themeSrcDirPath: string;
     keycloakifySrcDirPath: string;
     buildOptions: BuildOptionsLike;
     keycloakifyVersion: string;
 }): Promise<void> {
-    const {
-        projectDirPath,
-        reactAppBuildDirPath,
-        keycloakThemeBuildingDirPath,
-        themeSrcDirPath,
-        keycloakifySrcDirPath,
-        buildOptions,
-        keycloakifyVersion
-    } = params;
-
-    const getThemeDirPath = (themeType: ThemeType | "email") =>
-        pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources", "theme", buildOptions.themeName, themeType);
+    const { themeName, themeSrcDirPath, keycloakifySrcDirPath, buildOptions, keycloakifyVersion } = params;
+
+    const getThemeTypeDirPath = (params: { themeType: ThemeType | "email"; isRetrocompat?: true }) => {
+        const { themeType, isRetrocompat = false } = params;
+        return pathJoin(
+            buildOptions.keycloakifyBuildDirPath,
+            "src",
+            "main",
+            "resources",
+            "theme",
+            `${themeName}${isRetrocompat ? retrocompatPostfix : ""}`,
+            themeType
+        );
+    };
 
     let allCssGlobalsToDefine: Record<string, string> = {};
 
@@ -55,7 +58,7 @@ export async function generateTheme(params: {
             continue;
         }
 
-        const themeDirPath = getThemeDirPath(themeType);
+        const themeTypeDirPath = getThemeTypeDirPath({ themeType });
 
         copy_app_resources_to_theme_path: {
             const isFirstPass = themeType.indexOf(themeType) === 0;
@@ -65,13 +68,13 @@ export async function generateTheme(params: {
             }
 
             transformCodebase({
-                "destDirPath": pathJoin(themeDirPath, "resources", "build"),
-                "srcDirPath": reactAppBuildDirPath,
+                "destDirPath": pathJoin(themeTypeDirPath, "resources", "build"),
+                "srcDirPath": buildOptions.reactAppBuildDirPath,
                 "transformSourceCode": ({ filePath, sourceCode }) => {
                     //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
                     if (
                         isInside({
-                            "dirPath": pathJoin(reactAppBuildDirPath, basenameOfKeycloakDirInPublicDir),
+                            "dirPath": pathJoin(buildOptions.reactAppBuildDirPath, keycloak_resources),
                             filePath
                         })
                     ) {
@@ -114,7 +117,8 @@ export async function generateTheme(params: {
             generateFtlFilesCode_glob !== undefined
                 ? generateFtlFilesCode_glob
                 : generateFtlFilesCodeFactory({
-                      "indexHtmlCode": fs.readFileSync(pathJoin(reactAppBuildDirPath, "index.html")).toString("utf8"),
+                      themeName,
+                      "indexHtmlCode": fs.readFileSync(pathJoin(buildOptions.reactAppBuildDirPath, "index.html")).toString("utf8"),
                       "cssGlobalsToDefine": allCssGlobalsToDefine,
                       buildOptions,
                       keycloakifyVersion,
@@ -142,75 +146,77 @@ export async function generateTheme(params: {
         ].forEach(pageId => {
             const { ftlCode } = generateFtlFilesCode({ pageId });
 
-            fs.mkdirSync(themeDirPath, { "recursive": true });
+            fs.mkdirSync(themeTypeDirPath, { "recursive": true });
 
-            fs.writeFileSync(pathJoin(themeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
+            fs.writeFileSync(pathJoin(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
         });
 
         generateMessageProperties({
             themeSrcDirPath,
             themeType
         }).forEach(({ languageTag, propertiesFileSource }) => {
-            const messagesDirPath = pathJoin(themeDirPath, "messages");
+            const messagesDirPath = pathJoin(themeTypeDirPath, "messages");
 
-            fs.mkdirSync(pathJoin(themeDirPath, "messages"), { "recursive": true });
+            fs.mkdirSync(pathJoin(themeTypeDirPath, "messages"), { "recursive": true });
 
             const propertiesFilePath = pathJoin(messagesDirPath, `messages_${languageTag}.properties`);
 
             fs.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
         });
 
-        //TODO: Remove this block we left it for now only for backward compatibility
-        // we now have a separate script for this
-        copy_keycloak_resources_to_public: {
-            const keycloakDirInPublicDir = pathJoin(reactAppBuildDirPath, "..", "public", basenameOfKeycloakDirInPublicDir);
-
-            if (fs.existsSync(keycloakDirInPublicDir)) {
-                break copy_keycloak_resources_to_public;
-            }
-
-            await downloadKeycloakStaticResources({
-                projectDirPath,
-                "keycloakVersion": buildOptions.keycloakVersionDefaultAssets,
-                "themeDirPath": keycloakDirInPublicDir,
-                themeType,
-                "usedResources": undefined
-            });
-
-            if (themeType !== themeTypes[0]) {
-                break copy_keycloak_resources_to_public;
-            }
-
-            fs.writeFileSync(
-                pathJoin(keycloakDirInPublicDir, "README.txt"),
-                Buffer.from(
-                    // prettier-ignore
-                    [
-                        "This is just a test folder that helps develop",
-                        "the login and register page without having to run a Keycloak container"
-                    ].join(" ")
-                )
-            );
-
-            fs.writeFileSync(pathJoin(keycloakDirInPublicDir, ".gitignore"), Buffer.from("*", "utf8"));
-        }
-
         await downloadKeycloakStaticResources({
-            projectDirPath,
-            "keycloakVersion": buildOptions.keycloakVersionDefaultAssets,
-            themeDirPath,
+            "keycloakVersion": (() => {
+                switch (themeType) {
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                    case "login":
+                        return buildOptions.loginThemeResourcesFromKeycloakVersion;
+                }
+            })(),
+            "themeDirPath": pathResolve(pathJoin(themeTypeDirPath, "..")),
             themeType,
             "usedResources": readStaticResourcesUsage({
                 keycloakifySrcDirPath,
                 themeSrcDirPath,
                 themeType
-            })
+            }),
+            buildOptions
         });
 
         fs.writeFileSync(
-            pathJoin(themeDirPath, "theme.properties"),
-            Buffer.from([`parent=keycloak`, ...(buildOptions.extraThemeProperties ?? [])].join("\n\n"), "utf8")
+            pathJoin(themeTypeDirPath, "theme.properties"),
+            Buffer.from(
+                [
+                    `parent=${(() => {
+                        switch (themeType) {
+                            case "account":
+                                return accountV1;
+                            case "login":
+                                return "keycloak";
+                        }
+                        assert<Equals<typeof themeType, never>>(false);
+                    })()}`,
+                    ...(buildOptions.extraThemeProperties ?? [])
+                ].join("\n\n"),
+                "utf8"
+            )
         );
+
+        if (themeType === "account" && buildOptions.doBuildRetrocompatAccountTheme) {
+            transformCodebase({
+                "srcDirPath": themeTypeDirPath,
+                "destDirPath": getThemeTypeDirPath({ themeType, "isRetrocompat": true }),
+                "transformSourceCode": ({ filePath, sourceCode }) => {
+                    if (pathBasename(filePath) === "theme.properties") {
+                        return {
+                            "modifiedSourceCode": Buffer.from(sourceCode.toString("utf8").replace(`parent=${accountV1}`, "parent=keycloak"), "utf8")
+                        };
+                    }
+
+                    return { "modifiedSourceCode": sourceCode };
+                }
+            });
+        }
     }
 
     email: {
@@ -222,7 +228,7 @@ export async function generateTheme(params: {
 
         transformCodebase({
             "srcDirPath": emailThemeSrcDirPath,
-            "destDirPath": getThemeDirPath("email")
+            "destDirPath": getThemeTypeDirPath({ "themeType": "email" })
         });
     }
 }

package/src/bin/keycloakify/generateTheme/readExtraPageNames.ts

@@ -1,9 +1,10 @@
 import { crawl } from "../../tools/crawl";
-import { type ThemeType, accountThemePageIds, loginThemePageIds } from "../generateFtl";
+import { accountThemePageIds, loginThemePageIds } from "../generateFtl";
 import { id } from "tsafe/id";
 import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
+import type { ThemeType } from "../../constants";
 
 export function readExtraPagesNames(params: { themeSrcDirPath: string; themeType: ThemeType }): string[] {
     const { themeSrcDirPath, themeType } = params;

package/src/bin/keycloakify/generateTheme/readFieldNameUsage.ts

@@ -2,7 +2,7 @@ import { crawl } from "../../tools/crawl";
 import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
 import { join as pathJoin } from "path";
 import * as fs from "fs";
-import type { ThemeType } from "../generateFtl";
+import type { ThemeType } from "../../constants";
 
 /** Assumes the theme type exists */
 export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {

package/src/bin/keycloakify/generateTheme/readStaticResourcesUsage.ts

@@ -1,7 +1,7 @@
 import { crawl } from "../../tools/crawl";
 import { join as pathJoin } from "path";
 import * as fs from "fs";
-import type { ThemeType } from "../generateFtl";
+import type { ThemeType } from "../../constants";
 
 /** Assumes the theme type exists */
 export function readStaticResourcesUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): {

package/src/bin/keycloakify/keycloakify.ts

@@ -6,18 +6,16 @@ import { generateStartKeycloakTestingContainer } from "./generateStartKeycloakTe
 import * as fs from "fs";
 import { readBuildOptions } from "./BuildOptions";
 import { getLogger } from "../tools/logger";
-import jar from "../tools/jar";
 import { assert } from "tsafe/assert";
-import { Equals } from "tsafe";
 import { getThemeSrcDirPath } from "../getSrcDirPath";
 import { getProjectRoot } from "../tools/getProjectRoot";
 import { objectKeys } from "tsafe/objectKeys";
 
 export async function main() {
-    const projectDirPath = process.cwd();
+    const reactAppRootDirPath = process.cwd();
 
     const buildOptions = readBuildOptions({
-        projectDirPath,
+        reactAppRootDirPath,
         "processArgv": process.argv.slice(2)
     });
 
@@ -26,19 +24,14 @@ export async function main() {
 
     const keycloakifyDirPath = getProjectRoot();
 
-    const { themeSrcDirPath } = getThemeSrcDirPath({ projectDirPath });
+    const { themeSrcDirPath } = getThemeSrcDirPath({ reactAppRootDirPath });
 
-    for (const themeName of [buildOptions.themeName, ...buildOptions.extraThemeNames]) {
+    for (const themeName of buildOptions.themeNames) {
         await generateTheme({
-            projectDirPath,
-            "keycloakThemeBuildingDirPath": buildOptions.keycloakifyBuildDirPath,
+            themeName,
             themeSrcDirPath,
             "keycloakifySrcDirPath": pathJoin(keycloakifyDirPath, "src"),
-            "reactAppBuildDirPath": buildOptions.reactAppBuildDirPath,
-            "buildOptions": {
-                ...buildOptions,
-                "themeName": themeName
-            },
+            buildOptions,
             "keycloakifyVersion": (() => {
                 const version = JSON.parse(fs.readFileSync(pathJoin(keycloakifyDirPath, "package.json")).toString("utf8"))["version"];
 
@@ -49,8 +42,7 @@ export async function main() {
         });
     }
 
-    const { jarFilePath } = generateJavaStackFiles({
-        "keycloakThemeBuildingDirPath": buildOptions.keycloakifyBuildDirPath,
+    const { jarFilePath } = await generateJavaStackFiles({
         "implementedThemeTypes": (() => {
             const implementedThemeTypes = {
                 "login": false,
@@ -70,33 +62,14 @@ export async function main() {
         buildOptions
     });
 
-    switch (buildOptions.bundler) {
-        case "none":
-            logger.log("😱 Skipping bundling step, there will be no jar");
-            break;
-        case "keycloakify":
-            logger.log("🫶 Let keycloakify do its thang");
-            await jar({
-                "rootPath": buildOptions.keycloakifyBuildDirPath,
-                "version": buildOptions.themeVersion,
-                "groupId": buildOptions.groupId,
-                "artifactId": buildOptions.artifactId,
-                "targetPath": jarFilePath
-            });
-            break;
-        case "mvn":
-            logger.log("🫙 Run maven to deliver a jar");
-            child_process.execSync("mvn package", { "cwd": buildOptions.keycloakifyBuildDirPath });
-            break;
-        default:
-            assert<Equals<typeof buildOptions.bundler, never>>(false);
+    if (buildOptions.doCreateJar) {
+        child_process.execSync("mvn package", { "cwd": buildOptions.keycloakifyBuildDirPath });
     }
 
     // We want, however, to test in a container running the latest Keycloak version
     const containerKeycloakVersion = "21.1.2";
 
     generateStartKeycloakTestingContainer({
-        keycloakThemeBuildingDirPath: buildOptions.keycloakifyBuildDirPath,
         "keycloakVersion": containerKeycloakVersion,
         buildOptions
     });
@@ -104,9 +77,13 @@ export async function main() {
     logger.log(
         [
             "",
-            `✅ Your keycloak theme has been generated and bundled into .${pathSep}${pathRelative(projectDirPath, jarFilePath)} 🚀`,
-            `It is to be placed in "/opt/keycloak/providers" in the container running a quay.io/keycloak/keycloak Docker image.`,
-            "",
+            ...(!buildOptions.doCreateJar
+                ? []
+                : [
+                      `✅ Your keycloak theme has been generated and bundled into .${pathSep}${pathRelative(reactAppRootDirPath, jarFilePath)} 🚀`,
+                      `It is to be placed in "/opt/keycloak/providers" in the container running a quay.io/keycloak/keycloak Docker image.`,
+                      ""
+                  ]),
             //TODO: Restore when we find a good Helm chart for Keycloak.
             //"Using Helm (https://github.com/codecentric/helm-charts), edit to reflect:",
             "",
@@ -139,7 +116,7 @@ export async function main() {
             `To test your theme locally you can spin up a Keycloak ${containerKeycloakVersion} container image with the theme pre loaded by running:`,
             "",
             `👉 $ .${pathSep}${pathRelative(
-                projectDirPath,
+                reactAppRootDirPath,
                 pathJoin(buildOptions.keycloakifyBuildDirPath, generateStartKeycloakTestingContainer.basename)
             )} 👈`,
             "",
@@ -149,15 +126,15 @@ export async function main() {
             "- Log into the admin console 👉 http://localhost:8080/admin username: admin, password: admin 👈",
             `- Create a realm:                       Master         -> AddRealm   -> Name: myrealm`,
             `- Enable registration:                  Realm settings -> Login tab  -> User registration: on`,
-            `- Enable the Account theme (optional):  Realm settings -> Themes tab -> Account theme: ${buildOptions.themeName}`,
-            `                                        Clients        -> account    -> Login theme:   ${buildOptions.themeName}`,
-            `- Enable the email theme (optional):    Realm settings -> Themes tab -> Email theme:   ${buildOptions.themeName} (option will appear only if you have ran npx initialize-email-theme)`,
+            `- Enable the Account theme (optional):  Realm settings -> Themes tab -> Account theme: ${buildOptions.themeNames[0]}`,
+            `                                        Clients        -> account    -> Login theme:   ${buildOptions.themeNames[0]}`,
+            `- Enable the email theme (optional):    Realm settings -> Themes tab -> Email theme:   ${buildOptions.themeNames[0]} (option will appear only if you have ran npx initialize-email-theme)`,
             `- Create a client                       Clients        -> Create     -> Client ID:                       myclient`,
             `                                                                        Root URL:                        https://www.keycloak.org/app/`,
             `                                                                        Valid redirect URIs:             https://www.keycloak.org/app* http://localhost* (localhost is optional)`,
             `                                                                        Valid post logout redirect URIs: https://www.keycloak.org/app* http://localhost*`,
             `                                                                        Web origins:                     *`,
-            `                                                                        Login Theme:                     ${buildOptions.themeName}`,
+            `                                                                        Login Theme:                     ${buildOptions.themeNames[0]}`,
             `                                                                        Save (button at the bottom of the page)`,
             ``,
             `- Go to  👉  https://www.keycloak.org/app/ 👈 Click "Save" then "Sign in". You should see your login page`,

package/src/bin/keycloakify/parsedPackageJson.ts

@@ -4,8 +4,6 @@ import type { Equals } from "tsafe";
 import { z } from "zod";
 import { pathJoin } from "../tools/pathJoin";
 
-export const bundlers = ["mvn", "keycloakify", "none"] as const;
-export type Bundler = (typeof bundlers)[number];
 export type ParsedPackageJson = {
     name: string;
     version?: string;
@@ -15,12 +13,12 @@ export type ParsedPackageJson = {
         areAppAndKeycloakServerSharingSameDomain?: boolean;
         artifactId?: string;
         groupId?: string;
-        bundler?: Bundler;
-        keycloakVersionDefaultAssets?: string;
+        doCreateJar?: boolean;
+        loginThemeResourcesFromKeycloakVersion?: string;
         reactAppBuildDirPath?: string;
         keycloakifyBuildDirPath?: string;
-        themeName?: string;
-        extraThemeNames?: string[];
+        themeName?: string | string[];
+        doBuildRetrocompatAccountTheme?: boolean;
     };
 };
 
@@ -34,12 +32,12 @@ export const zParsedPackageJson = z.object({
             "areAppAndKeycloakServerSharingSameDomain": z.boolean().optional(),
             "artifactId": z.string().optional(),
             "groupId": z.string().optional(),
-            "bundler": z.enum(bundlers).optional(),
-            "keycloakVersionDefaultAssets": z.string().optional(),
+            "doCreateJar": z.boolean().optional(),
+            "loginThemeResourcesFromKeycloakVersion": z.string().optional(),
             "reactAppBuildDirPath": z.string().optional(),
             "keycloakifyBuildDirPath": z.string().optional(),
-            "themeName": z.string().optional(),
-            "extraThemeNames": z.array(z.string()).optional()
+            "themeName": z.union([z.string(), z.array(z.string())]).optional(),
+            "doBuildRetrocompatAccountTheme": z.boolean().optional()
         })
         .optional()
 });
@@ -47,11 +45,11 @@ export const zParsedPackageJson = z.object({
 assert<Equals<ReturnType<(typeof zParsedPackageJson)["parse"]>, ParsedPackageJson>>();
 
 let parsedPackageJson: undefined | ReturnType<(typeof zParsedPackageJson)["parse"]>;
-export function getParsedPackageJson(params: { projectDirPath: string }) {
-    const { projectDirPath } = params;
+export function getParsedPackageJson(params: { reactAppRootDirPath: string }) {
+    const { reactAppRootDirPath } = params;
     if (parsedPackageJson) {
         return parsedPackageJson;
     }
-    parsedPackageJson = zParsedPackageJson.parse(JSON.parse(fs.readFileSync(pathJoin(projectDirPath, "package.json")).toString("utf8")));
+    parsedPackageJson = zParsedPackageJson.parse(JSON.parse(fs.readFileSync(pathJoin(reactAppRootDirPath, "package.json")).toString("utf8")));
     return parsedPackageJson;
 }

package/src/bin/promptKeycloakVersion.ts

@@ -17,7 +17,7 @@ export async function promptKeycloakVersion() {
         return { getLatestsSemVersionedTag };
     })();
 
-    console.log("Initialize the directory with email template from which keycloak version?");
+    console.log("Select Keycloak version?");
 
     const tags = [
         ...(await getLatestsSemVersionedTag({

package/src/bin/tools/downloadAndUnzip.ts

@@ -162,7 +162,7 @@ export async function downloadAndUnzip(
     } & (
         | {
               doUseCache: true;
-              projectDirPath: string;
+              cacheDirPath: string;
           }
         | {
               doUseCache: false;
@@ -182,11 +182,10 @@ export async function downloadAndUnzip(
                   }
     });
 
-    const cacheRoot = !rest.doUseCache
-        ? `tmp_${Math.random().toString().slice(2, 12)}`
-        : pathJoin(process.env.XDG_CACHE_HOME ?? pathJoin(rest.projectDirPath, "node_modules", ".cache"), "keycloakify");
-    const zipFilePath = pathJoin(cacheRoot, `${zipFileBasename}.zip`);
-    const extractDirPath = pathJoin(cacheRoot, `tmp_unzip_${zipFileBasename}`);
+    const cacheDirPath = !rest.doUseCache ? `tmp_${Math.random().toString().slice(2, 12)}` : rest.cacheDirPath;
+
+    const zipFilePath = pathJoin(cacheDirPath, `${zipFileBasename}.zip`);
+    const extractDirPath = pathJoin(cacheDirPath, `tmp_unzip_${zipFileBasename}`);
 
     if (!(await exists(zipFilePath))) {
         const opts = await getFetchOptions();
@@ -226,7 +225,7 @@ export async function downloadAndUnzip(
     });
 
     if (!rest.doUseCache) {
-        await rm(cacheRoot, { "recursive": true });
+        await rm(cacheDirPath, { "recursive": true });
     } else {
         await rm(extractDirPath, { "recursive": true });
     }

package/src/bin/tools/getAbsoluteAndInOsFormatPath.ts

@@ -0,0 +1,15 @@
+import { isAbsolute as pathIsAbsolute, sep as pathSep, join as pathJoin } from "path";
+
+export function getAbsoluteAndInOsFormatPath(params: { pathIsh: string; cwd: string }): string {
+    const { pathIsh, cwd } = params;
+
+    let pathOut = pathIsh;
+
+    pathOut = pathOut.replace(/\//g, pathSep);
+
+    if (!pathIsAbsolute(pathOut)) {
+        pathOut = pathJoin(cwd, pathOut);
+    }
+
+    return pathOut;
+}

package/src/bin/tools/pathJoin.ts

@@ -2,5 +2,5 @@ export function pathJoin(...path: string[]): string {
     return path
         .map((part, i) => (i === 0 ? part : part.replace(/^\/+/, "")))
         .map((part, i) => (i === path.length - 1 ? part : part.replace(/\/+$/, "")))
-        .join("/");
+        .join(typeof process !== "undefined" && process.platform === "win32" ? "\\" : "/");
 }

package/src/login/kcContext/KcContext.ts

@@ -1,4 +1,5 @@
-import type { LoginThemePageId, ThemeType } from "keycloakify/bin/keycloakify/generateFtl";
+import type { LoginThemePageId } from "keycloakify/bin/keycloakify/generateFtl";
+import { type ThemeType } from "keycloakify/bin/constants";
 import { assert } from "tsafe/assert";
 import type { Equals } from "tsafe";
 import type { MessageKey } from "../i18n/i18n";

package/src/login/kcContext/createGetKcContext.ts

@@ -8,9 +8,8 @@ import { assert } from "tsafe/assert";
 import type { ExtendKcContext } from "./getKcContextFromWindow";
 import { getKcContextFromWindow } from "./getKcContextFromWindow";
 import { pathJoin } from "keycloakify/bin/tools/pathJoin";
-import { pathBasename } from "keycloakify/tools/pathBasename";
-import { resourcesCommonDirPathRelativeToPublicDir } from "keycloakify/bin/mockTestingResourcesPath";
 import { symToStr } from "tsafe/symToStr";
+import { resources_common } from "keycloakify/bin/constants";
 
 export function createGetKcContext<KcContextExtension extends { pageId: string } = never>(params?: {
     mockData?: readonly DeepPartial<ExtendKcContext<KcContextExtension>>[];
@@ -148,11 +147,7 @@ export function createGetKcContext<KcContextExtension extends { pageId: string }
             return { "kcContext": undefined as any };
         }
 
-        {
-            const { url } = realKcContext;
-
-            url.resourcesCommonPath = pathJoin(url.resourcesPath, pathBasename(resourcesCommonDirPathRelativeToPublicDir));
-        }
+        realKcContext.url.resourcesCommonPath = pathJoin(realKcContext.url.resourcesPath, resources_common);
 
         return { "kcContext": realKcContext as any };
     }

package/src/login/kcContext/kcContextMocks.ts

@@ -1,13 +1,11 @@
 import "minimal-polyfills/Object.fromEntries";
 import type { KcContext, Attribute } from "./KcContext";
-import { resourcesCommonDirPathRelativeToPublicDir, resourcesDirPathRelativeToPublicDir } from "keycloakify/bin/mockTestingResourcesPath";
+import { resources_common, keycloak_resources } from "keycloakify/bin/constants";
 import { pathJoin } from "keycloakify/bin/tools/pathJoin";
 import { id } from "tsafe/id";
 import { assert, type Equals } from "tsafe/assert";
 import type { LoginThemePageId } from "keycloakify/bin/keycloakify/generateFtl";
 
-const PUBLIC_URL = (typeof process !== "object" ? undefined : process.env?.["PUBLIC_URL"]) || "/";
-
 const attributes: Attribute[] = [
     {
         "validators": {
@@ -102,14 +100,18 @@ const attributes: Attribute[] = [
 
 const attributesByName = Object.fromEntries(attributes.map(attribute => [attribute.name, attribute])) as any;
 
+const PUBLIC_URL = (typeof process !== "object" ? undefined : process.env?.["PUBLIC_URL"]) || "/";
+
+const resourcesPath = pathJoin(PUBLIC_URL, keycloak_resources, "login", "resources");
+
 export const kcContextCommonMock: KcContext.Common = {
     "keycloakifyVersion": "0.0.0",
     "themeType": "login",
     "themeName": "my-theme-name",
     "url": {
         "loginAction": "#",
-        "resourcesPath": pathJoin(PUBLIC_URL, resourcesDirPathRelativeToPublicDir),
-        "resourcesCommonPath": pathJoin(PUBLIC_URL, resourcesCommonDirPathRelativeToPublicDir),
+        resourcesPath,
+        "resourcesCommonPath": pathJoin(resourcesPath, resources_common),
         "loginRestartFlowUrl": "/auth/realms/myrealm/login-actions/restart?client_id=account&tab_id=HoAx28ja4xg",
         "loginUrl": "/auth/realms/myrealm/login-actions/authenticate?client_id=account&tab_id=HoAx28ja4xg"
     },