keycloakify 10.0.0-rc.70 → 10.0.0-rc.71

package/bin/shared/KeycloakVersionRange.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=KeycloakVersionRange.js.map

package/bin/shared/buildContext.js

@@ -0,0 +1,488 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { parse as urlParse } from "url";
+import { join as pathJoin } from "path";
+import { getAbsoluteAndInOsFormatPath } from "../tools/getAbsoluteAndInOsFormatPath";
+import { getNpmWorkspaceRootDirPath } from "../tools/getNpmWorkspaceRootDirPath";
+import { z } from "zod";
+import * as fs from "fs";
+import { assert } from "tsafe/assert";
+import * as child_process from "child_process";
+import { vitePluginSubScriptEnvNames, buildForKeycloakMajorVersionEnvName } from "./constants";
+import { exclude } from "tsafe";
+import { crawl } from "../tools/crawl";
+import { themeTypes } from "./constants";
+import { objectFromEntries } from "tsafe/objectFromEntries";
+import { objectEntries } from "tsafe/objectEntries";
+import { id } from "tsafe/id";
+import { symToStr } from "tsafe/symToStr";
+import chalk from "chalk";
+export function getBuildContext(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { cliCommandOptions } = params;
+    const projectDirPath = (() => {
+        if (cliCommandOptions.projectDirPath === undefined) {
+            return process.cwd();
+        }
+        return getAbsoluteAndInOsFormatPath({
+            pathIsh: cliCommandOptions.projectDirPath,
+            cwd: process.cwd()
+        });
+    })();
+    const { resolvedViteConfig } = (() => {
+        if (fs
+            .readdirSync(projectDirPath)
+            .find(fileBasename => fileBasename.startsWith("vite.config")) ===
+            undefined) {
+            return { resolvedViteConfig: undefined };
+        }
+        const output = child_process
+            .execSync("npx vite", {
+            cwd: projectDirPath,
+            env: Object.assign(Object.assign({}, process.env), { [vitePluginSubScriptEnvNames.resolveViteConfig]: "true" })
+        })
+            .toString("utf8");
+        assert(output.includes(vitePluginSubScriptEnvNames.resolveViteConfig), "Seems like the Keycloakify's Vite plugin is not installed.");
+        const resolvedViteConfigStr = output
+            .split(vitePluginSubScriptEnvNames.resolveViteConfig)
+            .reverse()[0];
+        const resolvedViteConfig = JSON.parse(resolvedViteConfigStr);
+        return { resolvedViteConfig };
+    })();
+    const parsedPackageJson = (() => {
+        const zParsedPackageJson = z.object({
+            name: z.string(),
+            version: z.string().optional(),
+            homepage: z.string().optional(),
+            keycloakify: id((() => {
+                const zBuildOptions_packageJson = z.object({
+                    extraThemeProperties: z.array(z.string()).optional(),
+                    artifactId: z.string().optional(),
+                    groupId: z.string().optional(),
+                    loginThemeResourcesFromKeycloakVersion: z.string().optional(),
+                    projectBuildDirPath: z.string().optional(),
+                    keycloakifyBuildDirPath: z.string().optional(),
+                    kcContextExclusionsFtl: z.string().optional(),
+                    environmentVariables: z
+                        .array(z.object({
+                        name: z.string(),
+                        default: z.string()
+                    }))
+                        .optional(),
+                    themeName: z.union([z.string(), z.array(z.string())]).optional(),
+                    themeVersion: z.string().optional(),
+                    staticDirPathInProjectBuildDirPath: z.string().optional(),
+                    publicDirPath: z.string().optional(),
+                    keycloakVersionTargets: id((() => {
+                        const zKeycloakVersionTargets = z.union([
+                            z.object({
+                                hasAccountTheme: z.literal(true),
+                                "21-and-below": z.union([
+                                    z.boolean(),
+                                    z.string()
+                                ]),
+                                "23": z.union([z.boolean(), z.string()]),
+                                "24": z.union([z.boolean(), z.string()]),
+                                "25-and-above": z.union([z.boolean(), z.string()])
+                            }),
+                            z.object({
+                                hasAccountTheme: z.literal(false),
+                                "21-and-below": z.union([
+                                    z.boolean(),
+                                    z.string()
+                                ]),
+                                "22-and-above": z.union([z.boolean(), z.string()])
+                            })
+                        ]);
+                        {
+                            assert();
+                        }
+                        return zKeycloakVersionTargets;
+                    })()).optional()
+                });
+                {
+                    assert();
+                }
+                return zBuildOptions_packageJson;
+            })()).optional()
+        });
+        {
+            assert();
+        }
+        return zParsedPackageJson.parse(JSON.parse(fs.readFileSync(pathJoin(projectDirPath, "package.json")).toString("utf8")));
+    })();
+    const buildOptions = Object.assign(Object.assign({}, parsedPackageJson.keycloakify), resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildOptions);
+    const { themeSrcDirPath } = (() => {
+        const srcDirPath = pathJoin(projectDirPath, "src");
+        const themeSrcDirPath = crawl({
+            dirPath: srcDirPath,
+            returnedPathsType: "relative to dirPath"
+        })
+            .map(fileRelativePath => {
+            for (const themeSrcDirBasename of ["keycloak-theme", "keycloak_theme"]) {
+                const split = fileRelativePath.split(themeSrcDirBasename);
+                if (split.length === 2) {
+                    return pathJoin(srcDirPath, split[0] + themeSrcDirBasename);
+                }
+            }
+            return undefined;
+        })
+            .filter(exclude(undefined))[0];
+        if (themeSrcDirPath !== undefined) {
+            return { themeSrcDirPath };
+        }
+        for (const themeType of [...themeTypes, "email"]) {
+            if (!fs.existsSync(pathJoin(srcDirPath, themeType))) {
+                continue;
+            }
+            return { themeSrcDirPath: srcDirPath };
+        }
+        console.log(chalk.red([
+            "Can't locate your keycloak theme source directory.",
+            "See: https://docs.keycloakify.dev/v/v10/keycloakify-in-my-app/collocation"
+        ].join("\n")));
+        process.exit(1);
+    })();
+    const recordIsImplementedByThemeType = objectFromEntries(["login", "account", "email"].map(themeType => [
+        themeType,
+        fs.existsSync(pathJoin(themeSrcDirPath, themeType))
+    ]));
+    const themeNames = (() => {
+        if (buildOptions.themeName === undefined) {
+            return [
+                parsedPackageJson.name
+                    .replace(/^@(.*)/, "$1")
+                    .split("/")
+                    .join("-")
+            ];
+        }
+        if (typeof buildOptions.themeName === "string") {
+            return [buildOptions.themeName];
+        }
+        const [mainThemeName, ...themeVariantNames] = buildOptions.themeName;
+        assert(mainThemeName !== undefined);
+        return [mainThemeName, ...themeVariantNames];
+    })();
+    const projectBuildDirPath = (() => {
+        webpack: {
+            if (resolvedViteConfig !== undefined) {
+                break webpack;
+            }
+            if (buildOptions.projectBuildDirPath !== undefined) {
+                return getAbsoluteAndInOsFormatPath({
+                    pathIsh: buildOptions.projectBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return pathJoin(projectDirPath, "build");
+        }
+        return pathJoin(projectDirPath, resolvedViteConfig.buildDir);
+    })();
+    const { npmWorkspaceRootDirPath } = getNpmWorkspaceRootDirPath({
+        projectDirPath,
+        dependencyExpected: "keycloakify"
+    });
+    const bundler = resolvedViteConfig !== undefined ? "vite" : "webpack";
+    return {
+        bundler,
+        themeVersion: (_b = (_a = buildOptions.themeVersion) !== null && _a !== void 0 ? _a : parsedPackageJson.version) !== null && _b !== void 0 ? _b : "0.0.0",
+        themeNames,
+        extraThemeProperties: buildOptions.extraThemeProperties,
+        groupId: (() => {
+            var _a, _b, _c, _d, _e;
+            const fallbackGroupId = `${themeNames[0]}.keycloak`;
+            return ((_b = (_a = process.env.KEYCLOAKIFY_GROUP_ID) !== null && _a !== void 0 ? _a : buildOptions.groupId) !== null && _b !== void 0 ? _b : (parsedPackageJson.homepage === undefined
+                ? fallbackGroupId
+                : (_e = (_d = (_c = urlParse(parsedPackageJson.homepage)
+                    .host) === null || _c === void 0 ? void 0 : _c.replace(/:[0-9]+$/, "")) === null || _d === void 0 ? void 0 : _d.split(".").reverse().join(".")) !== null && _e !== void 0 ? _e : fallbackGroupId) + ".keycloak");
+        })(),
+        artifactId: (_d = (_c = process.env.KEYCLOAKIFY_ARTIFACT_ID) !== null && _c !== void 0 ? _c : buildOptions.artifactId) !== null && _d !== void 0 ? _d : `${themeNames[0]}-keycloak-theme`,
+        loginThemeResourcesFromKeycloakVersion: (_e = buildOptions.loginThemeResourcesFromKeycloakVersion) !== null && _e !== void 0 ? _e : "24.0.4",
+        projectDirPath,
+        projectBuildDirPath,
+        keycloakifyBuildDirPath: (() => {
+            if (buildOptions.keycloakifyBuildDirPath !== undefined) {
+                return getAbsoluteAndInOsFormatPath({
+                    pathIsh: buildOptions.keycloakifyBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return pathJoin(projectDirPath, (resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildDir) === undefined
+                ? "build_keycloak"
+                : `${resolvedViteConfig.buildDir}_keycloak`);
+        })(),
+        publicDirPath: (() => {
+            if (process.env.PUBLIC_DIR_PATH !== undefined) {
+                return getAbsoluteAndInOsFormatPath({
+                    pathIsh: process.env.PUBLIC_DIR_PATH,
+                    cwd: projectDirPath
+                });
+            }
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                if (buildOptions.publicDirPath !== undefined) {
+                    return getAbsoluteAndInOsFormatPath({
+                        pathIsh: buildOptions.publicDirPath,
+                        cwd: projectDirPath
+                    });
+                }
+                return pathJoin(projectDirPath, "public");
+            }
+            return pathJoin(projectDirPath, resolvedViteConfig.publicDir);
+        })(),
+        cacheDirPath: (() => {
+            const cacheDirPath = pathJoin((() => {
+                if (process.env.XDG_CACHE_HOME !== undefined) {
+                    return getAbsoluteAndInOsFormatPath({
+                        pathIsh: process.env.XDG_CACHE_HOME,
+                        cwd: process.cwd()
+                    });
+                }
+                return pathJoin(npmWorkspaceRootDirPath, "node_modules", ".cache");
+            })(), "keycloakify");
+            return cacheDirPath;
+        })(),
+        urlPathname: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                const { homepage } = parsedPackageJson;
+                let url = undefined;
+                if (homepage !== undefined) {
+                    url = new URL(homepage);
+                }
+                if (url === undefined) {
+                    return undefined;
+                }
+                const out = url.pathname.replace(/([^/])$/, "$1/");
+                return out === "/" ? undefined : out;
+            }
+            return resolvedViteConfig.urlPathname;
+        })(),
+        assetsDirPath: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                if (buildOptions.staticDirPathInProjectBuildDirPath !== undefined) {
+                    getAbsoluteAndInOsFormatPath({
+                        pathIsh: buildOptions.staticDirPathInProjectBuildDirPath,
+                        cwd: projectBuildDirPath
+                    });
+                }
+                return pathJoin(projectBuildDirPath, "static");
+            }
+            return pathJoin(projectBuildDirPath, resolvedViteConfig.assetsDir);
+        })(),
+        npmWorkspaceRootDirPath,
+        kcContextExclusionsFtlCode: (() => {
+            if (buildOptions.kcContextExclusionsFtl === undefined) {
+                return undefined;
+            }
+            if (buildOptions.kcContextExclusionsFtl.endsWith(".ftl")) {
+                const kcContextExclusionsFtlPath = getAbsoluteAndInOsFormatPath({
+                    pathIsh: buildOptions.kcContextExclusionsFtl,
+                    cwd: projectDirPath
+                });
+                return fs.readFileSync(kcContextExclusionsFtlPath).toString("utf8");
+            }
+            return buildOptions.kcContextExclusionsFtl;
+        })(),
+        environmentVariables: (_f = buildOptions.environmentVariables) !== null && _f !== void 0 ? _f : [],
+        recordIsImplementedByThemeType,
+        themeSrcDirPath,
+        jarTargets: (() => {
+            const getDefaultJarFileBasename = (range) => `keycloak-theme-for-kc-${range}.jar`;
+            build_for_specific_keycloak_major_version: {
+                const buildForKeycloakMajorVersionNumber = (() => {
+                    const envValue = process.env[buildForKeycloakMajorVersionEnvName];
+                    if (envValue === undefined) {
+                        return undefined;
+                    }
+                    const major = parseInt(envValue);
+                    assert(!isNaN(major));
+                    return major;
+                })();
+                if (buildForKeycloakMajorVersionNumber === undefined) {
+                    break build_for_specific_keycloak_major_version;
+                }
+                const keycloakVersionRange = (() => {
+                    const doesImplementAccountTheme = recordIsImplementedByThemeType.account;
+                    if (doesImplementAccountTheme) {
+                        const keycloakVersionRange = (() => {
+                            if (buildForKeycloakMajorVersionNumber <= 21) {
+                                return "21-and-below";
+                            }
+                            assert(buildForKeycloakMajorVersionNumber !== 22);
+                            if (buildForKeycloakMajorVersionNumber === 23) {
+                                return "23";
+                            }
+                            if (buildForKeycloakMajorVersionNumber === 24) {
+                                return "24";
+                            }
+                            return "25-and-above";
+                        })();
+                        assert();
+                        return keycloakVersionRange;
+                    }
+                    else {
+                        const keycloakVersionRange = (() => {
+                            if (buildForKeycloakMajorVersionNumber <= 21) {
+                                return "21-and-below";
+                            }
+                            return "22-and-above";
+                        })();
+                        assert();
+                        return keycloakVersionRange;
+                    }
+                })();
+                const jarFileBasename = (() => {
+                    use_custom_jar_basename: {
+                        const { keycloakVersionTargets } = buildOptions;
+                        if (keycloakVersionTargets === undefined) {
+                            break use_custom_jar_basename;
+                        }
+                        const entry = objectEntries(keycloakVersionTargets).find(([keycloakVersionRange_entry]) => keycloakVersionRange_entry === keycloakVersionRange);
+                        if (entry === undefined) {
+                            break use_custom_jar_basename;
+                        }
+                        const maybeJarFileBasename = entry[1];
+                        if (typeof maybeJarFileBasename !== "string") {
+                            break use_custom_jar_basename;
+                        }
+                        return maybeJarFileBasename;
+                    }
+                    return getDefaultJarFileBasename(keycloakVersionRange);
+                })();
+                return [
+                    {
+                        keycloakVersionRange,
+                        jarFileBasename
+                    }
+                ];
+            }
+            const jarTargets_default = (() => {
+                const jarTargets = [];
+                if (recordIsImplementedByThemeType.account) {
+                    for (const keycloakVersionRange of [
+                        "21-and-below",
+                        "23",
+                        "24",
+                        "25-and-above"
+                    ]) {
+                        assert(true);
+                        jarTargets.push({
+                            keycloakVersionRange,
+                            jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                        });
+                    }
+                }
+                else {
+                    for (const keycloakVersionRange of [
+                        "21-and-below",
+                        "22-and-above"
+                    ]) {
+                        assert(true);
+                        jarTargets.push({
+                            keycloakVersionRange,
+                            jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                        });
+                    }
+                }
+                return jarTargets;
+            })();
+            if (buildOptions.keycloakVersionTargets === undefined) {
+                return jarTargets_default;
+            }
+            if (buildOptions.keycloakVersionTargets.hasAccountTheme !==
+                recordIsImplementedByThemeType.account) {
+                console.log(chalk.red((() => {
+                    const { keycloakVersionTargets } = buildOptions;
+                    let message = `Bad ${symToStr({ keycloakVersionTargets })} configuration.\n`;
+                    if (keycloakVersionTargets.hasAccountTheme) {
+                        message +=
+                            "Your codebase does not seem to implement an account theme ";
+                    }
+                    else {
+                        message += "Your codebase implements an account theme ";
+                    }
+                    const { hasAccountTheme } = keycloakVersionTargets;
+                    message += `but you have set ${symToStr({ keycloakVersionTargets })}.${symToStr({ hasAccountTheme })}`;
+                    message += ` to ${hasAccountTheme} in your `;
+                    message += (() => {
+                        switch (bundler) {
+                            case "vite":
+                                return "vite.config.ts";
+                            case "webpack":
+                                return "package.json";
+                        }
+                        assert(false);
+                    })();
+                    message += `. Please set it to ${!hasAccountTheme} `;
+                    message +=
+                        "and fill up the relevant keycloak version ranges.\n";
+                    message += "Example:\n";
+                    message += JSON.stringify(id({
+                        keycloakVersionTargets: Object.assign({ hasAccountTheme: recordIsImplementedByThemeType.account }, objectFromEntries(jarTargets_default.map(({ keycloakVersionRange, jarFileBasename }) => [
+                            keycloakVersionRange,
+                            jarFileBasename
+                        ])))
+                    }), null, 2);
+                    message +=
+                        "\nSee: https://docs.keycloakify.dev/v/v10/targetting-specific-keycloak-versions";
+                    return message;
+                })()));
+                process.exit(1);
+            }
+            const jarTargets = [];
+            const _a = buildOptions.keycloakVersionTargets, { hasAccountTheme } = _a, rest = __rest(_a, ["hasAccountTheme"]);
+            for (const [keycloakVersionRange, jarNameOrBoolean] of objectEntries(rest)) {
+                if (jarNameOrBoolean === false) {
+                    continue;
+                }
+                if (jarNameOrBoolean === true) {
+                    jarTargets.push({
+                        keycloakVersionRange: keycloakVersionRange,
+                        jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                    });
+                    continue;
+                }
+                const jarFileBasename = jarNameOrBoolean;
+                if (!jarFileBasename.endsWith(".jar")) {
+                    console.log(chalk.red(`Bad ${jarFileBasename} should end with '.jar'\n`));
+                    process.exit(1);
+                }
+                if (jarFileBasename.includes("/") || jarFileBasename.includes("\\")) {
+                    console.log(chalk.red([
+                        `Invalid ${jarFileBasename}. It's not supposed to be a path,`,
+                        `Only the basename of the jar file is expected.`,
+                        `Example: keycloak-theme.jar`
+                    ].join(" ")));
+                    process.exit(1);
+                }
+                jarTargets.push({
+                    keycloakVersionRange: keycloakVersionRange,
+                    jarFileBasename: jarNameOrBoolean
+                });
+            }
+            if (jarTargets.length === 0) {
+                console.log(chalk.red("All jar targets are disabled. Please enable at least one jar target."));
+                process.exit(1);
+            }
+            return jarTargets;
+        })()
+    };
+}
+//# sourceMappingURL=buildContext.js.map

package/bin/shared/constants.js

@@ -0,0 +1,59 @@
+export const nameOfTheLocalizationRealmOverridesUserProfileProperty = "__localizationRealmOverridesUserProfile";
+export const keycloak_resources = "keycloak-resources";
+export const resources_common = "resources-common";
+export const lastKeycloakVersionWithAccountV1 = "21.1.2";
+export const basenameOfTheKeycloakifyResourcesDir = "dist";
+export const themeTypes = ["login", "account"];
+export const accountV1ThemeName = "account-v1";
+export const vitePluginSubScriptEnvNames = {
+    runPostBuildScript: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    resolveViteConfig: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+};
+export const buildForKeycloakMajorVersionEnvName = "KEYCLOAKIFY_BUILD_FOR_KEYCLOAK_MAJOR_VERSION";
+export const loginThemePageIds = [
+    "login.ftl",
+    "login-username.ftl",
+    "login-password.ftl",
+    "webauthn-authenticate.ftl",
+    "webauthn-register.ftl",
+    "register.ftl",
+    "info.ftl",
+    "error.ftl",
+    "login-reset-password.ftl",
+    "login-verify-email.ftl",
+    "terms.ftl",
+    "login-oauth2-device-verify-user-code.ftl",
+    "login-oauth-grant.ftl",
+    "login-otp.ftl",
+    "login-update-profile.ftl",
+    "login-update-password.ftl",
+    "login-idp-link-confirm.ftl",
+    "login-idp-link-email.ftl",
+    "login-page-expired.ftl",
+    "login-config-totp.ftl",
+    "logout-confirm.ftl",
+    "idp-review-user-profile.ftl",
+    "update-email.ftl",
+    "select-authenticator.ftl",
+    "saml-post-form.ftl",
+    "delete-credential.ftl",
+    "code.ftl",
+    "delete-account-confirm.ftl",
+    "frontchannel-logout.ftl",
+    "login-recovery-authn-code-config.ftl",
+    "login-recovery-authn-code-input.ftl",
+    "login-reset-otp.ftl",
+    "login-x509-info.ftl",
+    "webauthn-error.ftl"
+];
+export const accountThemePageIds = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+];
+export const containerName = "keycloak-keycloakify";
+//# sourceMappingURL=constants.js.map

package/bin/shared/copyKeycloakResourcesToPublic.js

@@ -0,0 +1,61 @@
+import { downloadKeycloakStaticResources } from "./downloadKeycloakStaticResources";
+import { join as pathJoin, relative as pathRelative } from "path";
+import { themeTypes, keycloak_resources, lastKeycloakVersionWithAccountV1 } from "../shared/constants";
+import { readThisNpmPackageVersion } from "../tools/readThisNpmPackageVersion";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+import { rmSync } from "../tools/fs.rmSync";
+assert();
+export async function copyKeycloakResourcesToPublic(params) {
+    const { buildContext } = params;
+    const destDirPath = pathJoin(buildContext.publicDirPath, keycloak_resources);
+    const keycloakifyBuildinfoFilePath = pathJoin(destDirPath, "keycloakify.buildinfo");
+    const keycloakifyBuildinfoRaw = JSON.stringify({
+        destDirPath,
+        keycloakifyVersion: readThisNpmPackageVersion(),
+        buildContext: {
+            loginThemeResourcesFromKeycloakVersion: readThisNpmPackageVersion(),
+            cacheDirPath: pathRelative(destDirPath, buildContext.cacheDirPath),
+            npmWorkspaceRootDirPath: pathRelative(destDirPath, buildContext.npmWorkspaceRootDirPath)
+        }
+    }, null, 2);
+    skip_if_already_done: {
+        if (!fs.existsSync(keycloakifyBuildinfoFilePath)) {
+            break skip_if_already_done;
+        }
+        const keycloakifyBuildinfoRaw_previousRun = fs
+            .readFileSync(keycloakifyBuildinfoFilePath)
+            .toString("utf8");
+        if (keycloakifyBuildinfoRaw_previousRun !== keycloakifyBuildinfoRaw) {
+            break skip_if_already_done;
+        }
+        return;
+    }
+    rmSync(destDirPath, { force: true, recursive: true });
+    fs.mkdirSync(destDirPath, { recursive: true });
+    fs.writeFileSync(pathJoin(destDirPath, ".gitignore"), Buffer.from("*", "utf8"));
+    for (const themeType of themeTypes) {
+        await downloadKeycloakStaticResources({
+            keycloakVersion: (() => {
+                switch (themeType) {
+                    case "login":
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
+                    case "account":
+                        return lastKeycloakVersionWithAccountV1;
+                }
+            })(),
+            themeType,
+            themeDirPath: destDirPath,
+            buildContext
+        });
+    }
+    fs.writeFileSync(pathJoin(destDirPath, "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\n",
+        "This directory will be automatically excluded from the final build."
+    ].join(" ")));
+    fs.writeFileSync(keycloakifyBuildinfoFilePath, Buffer.from(keycloakifyBuildinfoRaw, "utf8"));
+}
+//# sourceMappingURL=copyKeycloakResourcesToPublic.js.map

package/bin/shared/downloadKeycloakDefaultTheme.js

@@ -0,0 +1,123 @@
+import { join as pathJoin, relative as pathRelative } from "path";
+import { assert } from "tsafe/assert";
+import { lastKeycloakVersionWithAccountV1 } from "./constants";
+import { downloadAndExtractArchive } from "../tools/downloadAndExtractArchive";
+assert();
+export async function downloadKeycloakDefaultTheme(params) {
+    const { keycloakVersion, buildContext } = params;
+    let kcNodeModulesKeepFilePaths = undefined;
+    let kcNodeModulesKeepFilePaths_lastAccountV1 = undefined;
+    const { extractedDirPath } = await downloadAndExtractArchive({
+        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
+        cacheDirPath: buildContext.cacheDirPath,
+        npmWorkspaceRootDirPath: buildContext.npmWorkspaceRootDirPath,
+        uniqueIdOfOnOnArchiveFile: "downloadKeycloakDefaultTheme",
+        onArchiveFile: async (params) => {
+            const fileRelativePath = pathRelative("theme", params.fileRelativePath);
+            if (fileRelativePath.startsWith("..")) {
+                return;
+            }
+            const { readFile, writeFile } = params;
+            skip_keycloak_v2: {
+                if (!fileRelativePath.startsWith(pathJoin("keycloak.v2"))) {
+                    break skip_keycloak_v2;
+                }
+                return;
+            }
+            last_account_v1_transformations: {
+                if (lastKeycloakVersionWithAccountV1 !== keycloakVersion) {
+                    break last_account_v1_transformations;
+                }
+                skip_web_modules: {
+                    if (!fileRelativePath.startsWith(pathJoin("keycloak", "common", "resources", "web_modules"))) {
+                        break skip_web_modules;
+                    }
+                    return;
+                }
+                skip_lib: {
+                    if (!fileRelativePath.startsWith(pathJoin("keycloak", "common", "resources", "lib"))) {
+                        break skip_lib;
+                    }
+                    return;
+                }
+                skip_node_modules: {
+                    if (!fileRelativePath.startsWith(pathJoin("keycloak", "common", "resources", "node_modules"))) {
+                        break skip_node_modules;
+                    }
+                    if (kcNodeModulesKeepFilePaths_lastAccountV1 === undefined) {
+                        kcNodeModulesKeepFilePaths_lastAccountV1 = [
+                            pathJoin("patternfly", "dist", "css", "patternfly.min.css"),
+                            pathJoin("patternfly", "dist", "css", "patternfly-additions.min.css"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff2"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Semibold-webfont.woff2")
+                        ];
+                    }
+                    for (const keepPath of kcNodeModulesKeepFilePaths_lastAccountV1) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            break skip_node_modules;
+                        }
+                    }
+                    return;
+                }
+                patch_account_css: {
+                    if (fileRelativePath !==
+                        pathJoin("keycloak", "account", "resources", "css", "account.css")) {
+                        break patch_account_css;
+                    }
+                    await writeFile({
+                        fileRelativePath,
+                        modifiedData: Buffer.from((await readFile())
+                            .toString("utf8")
+                            .replace("top: -34px;", "top: -34px !important;"), "utf8")
+                    });
+                    return;
+                }
+            }
+            skip_unused_resources: {
+                if (keycloakVersion !== "24.0.4") {
+                    break skip_unused_resources;
+                }
+                skip_node_modules: {
+                    if (!fileRelativePath.startsWith(pathJoin("keycloak", "common", "resources", "node_modules"))) {
+                        break skip_node_modules;
+                    }
+                    if (kcNodeModulesKeepFilePaths === undefined) {
+                        kcNodeModulesKeepFilePaths = [
+                            pathJoin("@patternfly", "patternfly", "patternfly.min.css"),
+                            pathJoin("patternfly", "dist", "css", "patternfly.min.css"),
+                            pathJoin("patternfly", "dist", "css", "patternfly-additions.min.css"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
+                            pathJoin("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
+                            pathJoin("patternfly", "dist", "fonts", "fontawesome-webfont.woff2"),
+                            pathJoin("jquery", "dist", "jquery.min.js")
+                        ];
+                    }
+                    for (const keepPath of kcNodeModulesKeepFilePaths) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            break skip_node_modules;
+                        }
+                    }
+                    return;
+                }
+                skip_vendor: {
+                    if (!fileRelativePath.startsWith(pathJoin("keycloak", "common", "resources", "vendor"))) {
+                        break skip_vendor;
+                    }
+                    return;
+                }
+                skip_rollup_config: {
+                    if (fileRelativePath !==
+                        pathJoin("keycloak", "common", "resources", "rollup.config.js")) {
+                        break skip_rollup_config;
+                    }
+                    return;
+                }
+            }
+            await writeFile({ fileRelativePath });
+        }
+    });
+    return { defaultThemeDirPath: extractedDirPath };
+}
+//# sourceMappingURL=downloadKeycloakDefaultTheme.js.map

package/bin/shared/downloadKeycloakStaticResources.js

@@ -0,0 +1,34 @@
+import { transformCodebase } from "../tools/transformCodebase";
+import { join as pathJoin } from "path";
+import { downloadKeycloakDefaultTheme } from "./downloadKeycloakDefaultTheme";
+import { resources_common } from "./constants";
+import { assert } from "tsafe/assert";
+import { existsAsync } from "../tools/fs.existsAsync";
+assert();
+export async function downloadKeycloakStaticResources(params) {
+    const { themeType, themeDirPath, keycloakVersion, buildContext } = params;
+    const { defaultThemeDirPath } = await downloadKeycloakDefaultTheme({
+        keycloakVersion,
+        buildContext
+    });
+    const resourcesDirPath = pathJoin(themeDirPath, themeType, "resources");
+    repatriate_base_resources: {
+        const srcDirPath = pathJoin(defaultThemeDirPath, "base", themeType, "resources");
+        if (!(await existsAsync(srcDirPath))) {
+            break repatriate_base_resources;
+        }
+        transformCodebase({
+            srcDirPath,
+            destDirPath: resourcesDirPath
+        });
+    }
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", themeType, "resources"),
+        destDirPath: resourcesDirPath
+    });
+    transformCodebase({
+        srcDirPath: pathJoin(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: pathJoin(resourcesDirPath, resources_common)
+    });
+}
+//# sourceMappingURL=downloadKeycloakStaticResources.js.map

package/bin/shared/generateKcGenTs.js

@@ -0,0 +1,41 @@
+import { assert } from "tsafe/assert";
+import * as fs from "fs/promises";
+import { join as pathJoin } from "path";
+import { existsAsync } from "../tools/fs.existsAsync";
+assert();
+export async function generateKcGenTs(params) {
+    const { buildContext } = params;
+    const filePath = pathJoin(buildContext.themeSrcDirPath, "kc.gen.ts");
+    const currentContent = (await existsAsync(filePath))
+        ? await fs.readFile(filePath)
+        : undefined;
+    const newContent = Buffer.from([
+        `/* prettier-ignore-start */`,
+        ``,
+        `/* eslint-disable */`,
+        ``,
+        `// @ts-nocheck`,
+        ``,
+        `// noinspection JSUnusedGlobalSymbols`,
+        ``,
+        `// This file is auto-generated by Keycloakify`,
+        ``,
+        `export type ThemeName = ${buildContext.themeNames.map(themeName => `"${themeName}"`).join(" | ")};`,
+        ``,
+        `export const themeNames: ThemeName[] = [${buildContext.themeNames.map(themeName => `"${themeName}"`).join(", ")}];`,
+        ``,
+        `export type KcEnvName = ${buildContext.environmentVariables.length === 0 ? "never" : buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(" | ")};`,
+        ``,
+        `export const kcEnvNames: KcEnvName[] = [${buildContext.environmentVariables.map(({ name }) => `"${name}"`).join(", ")}];`,
+        ``,
+        `export const kcEnvDefaults: Record<KcEnvName, string> = ${JSON.stringify(Object.fromEntries(buildContext.environmentVariables.map(({ name, default: defaultValue }) => [name, defaultValue])), null, 2)};`,
+        ``,
+        `/* prettier-ignore-end */`,
+        ``
+    ].join("\n"), "utf8");
+    if (currentContent !== undefined && currentContent.equals(newContent)) {
+        return;
+    }
+    await fs.writeFile(filePath, newContent);
+}
+//# sourceMappingURL=generateKcGenTs.js.map

package/bin/shared/metaInfKeycloakThemes.js

@@ -0,0 +1,20 @@
+import { join as pathJoin, dirname as pathDirname } from "path";
+import * as fs from "fs";
+export function writeMetaInfKeycloakThemes(params) {
+    const { resourcesDirPath, getNewMetaInfKeycloakTheme } = params;
+    const filePath = pathJoin(resourcesDirPath, "META-INF", "keycloak-themes.json");
+    const currentMetaInfKeycloakTheme = !fs.existsSync(filePath)
+        ? undefined
+        : JSON.parse(fs.readFileSync(filePath).toString("utf8"));
+    const newMetaInfKeycloakThemes = getNewMetaInfKeycloakTheme({
+        metaInfKeycloakTheme: currentMetaInfKeycloakTheme
+    });
+    {
+        const dirPath = pathDirname(filePath);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    fs.writeFileSync(filePath, Buffer.from(JSON.stringify(newMetaInfKeycloakThemes, null, 2), "utf8"));
+}
+//# sourceMappingURL=metaInfKeycloakThemes.js.map

package/bin/shared/promptKeycloakVersion.js

@@ -0,0 +1,76 @@
+import { getLatestsSemVersionedTagFactory } from "../tools/octokit-addons/getLatestsSemVersionedTag";
+import { Octokit } from "@octokit/rest";
+import cliSelect from "cli-select";
+import { SemVer } from "../tools/SemVer";
+import { join as pathJoin, dirname as pathDirname } from "path";
+import * as fs from "fs";
+import { id } from "tsafe/id";
+export async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
+    const { getLatestsSemVersionedTag } = (() => {
+        const { octokit } = (() => {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const octokit = new Octokit(githubToken === undefined ? undefined : { auth: githubToken });
+            return { octokit };
+        })();
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
+        return { getLatestsSemVersionedTag };
+    })();
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (async () => {
+        const cacheFilePath = pathJoin(cacheDirPath, "keycloak-versions.json");
+        use_cache: {
+            if (!fs.existsSync(cacheFilePath)) {
+                break use_cache;
+            }
+            const cache = JSON.parse(fs.readFileSync(cacheFilePath).toString("utf8"));
+            if (Date.now() - cache.time > 3600000) {
+                fs.unlinkSync(cacheFilePath);
+                break use_cache;
+            }
+            return cache.semVersionedTags;
+        }
+        const semVersionedTags = await getLatestsSemVersionedTag({
+            count: 50,
+            owner: "keycloak",
+            repo: "keycloak"
+        });
+        {
+            const dirPath = pathDirname(cacheFilePath);
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        fs.writeFileSync(cacheFilePath, JSON.stringify(id({
+            time: Date.now(),
+            semVersionedTags
+        }), null, 2));
+        return semVersionedTags;
+    })();
+    semVersionedTags.forEach(semVersionedTag => {
+        if (startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor) {
+            return;
+        }
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            return;
+        }
+        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (currentSemVersionedTag !== undefined &&
+            SemVer.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            return;
+        }
+        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
+    });
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
+    const { value } = await cliSelect({
+        values: lastMajorVersions
+    }).catch(() => {
+        process.exit(-1);
+    });
+    const keycloakVersion = value.split(" ")[0];
+    return { keycloakVersion };
+}
+//# sourceMappingURL=promptKeycloakVersion.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "10.0.0-rc.70",
+    "version": "10.0.0-rc.71",
     "description": "Create Keycloak themes using React",
     "repository": {
         "type": "git",
@@ -786,6 +786,15 @@
         "bin/837.index.js",
         "bin/932.index.js",
         "bin/97.index.js",
+        "bin/shared/buildContext.js",
+        "bin/shared/constants.js",
+        "bin/shared/copyKeycloakResourcesToPublic.js",
+        "bin/shared/downloadKeycloakDefaultTheme.js",
+        "bin/shared/downloadKeycloakStaticResources.js",
+        "bin/shared/generateKcGenTs.js",
+        "bin/shared/KeycloakVersionRange.js",
+        "bin/shared/metaInfKeycloakThemes.js",
+        "bin/shared/promptKeycloakVersion.js",
         "bin/shared/buildContext.d.ts",
         "bin/shared/constants.d.ts",
         "bin/shared/copyKeycloakResourcesToPublic.d.ts",