keycloakify 10.0.0-rc.14 → 10.0.0-rc.140

package/src/bin/tools/fetchProxyOptions.ts

@@ -1,73 +1,117 @@
-import { exec as execCallback } from "child_process";
-import { readFile } from "fs/promises";
 import { type FetchOptions } from "make-fetch-happen";
-import { promisify } from "util";
-
-function ensureArray<T>(arg0: T | T[]) {
-    return Array.isArray(arg0) ? arg0 : typeof arg0 === "undefined" ? [] : [arg0];
-}
-
-function ensureSingleOrNone<T>(arg0: T | T[]) {
-    if (!Array.isArray(arg0)) return arg0;
-    if (arg0.length === 0) return undefined;
-    if (arg0.length === 1) return arg0[0];
-    throw new Error("Illegal configuration, expected a single value but found multiple: " + arg0.map(String).join(", "));
-}
-
-type NPMConfig = Record<string, string | string[]>;
-
-/**
- * Get npm configuration as map
- */
-async function getNmpConfig(params: { npmWorkspaceRootDirPath: string }) {
-    const { npmWorkspaceRootDirPath } = params;
-
-    const exec = promisify(execCallback);
-
-    const stdout = await exec("npm config get", { "encoding": "utf8", "cwd": npmWorkspaceRootDirPath }).then(({ stdout }) => stdout);
-
-    const npmConfigReducer = (cfg: NPMConfig, [key, value]: [string, string]) =>
-        key in cfg ? { ...cfg, [key]: [...ensureArray(cfg[key]), value] } : { ...cfg, [key]: value };
-
-    return stdout
-        .split("\n")
-        .filter(line => !line.startsWith(";"))
-        .map(line => line.trim())
-        .map(line => line.split("=", 2) as [string, string])
-        .reduce(npmConfigReducer, {} as NPMConfig);
-}
-
-export type ProxyFetchOptions = Pick<FetchOptions, "proxy" | "noProxy" | "strictSSL" | "cert" | "ca">;
+import * as child_process from "child_process";
+import * as fs from "fs";
+import { exclude } from "tsafe/exclude";
+
+export type ProxyFetchOptions = Pick<
+    FetchOptions,
+    "proxy" | "noProxy" | "strictSSL" | "cert" | "ca"
+>;
+
+export function getProxyFetchOptions(params: {
+    npmConfigGetCwd: string;
+}): ProxyFetchOptions {
+    const { npmConfigGetCwd } = params;
+
+    const cfg = (() => {
+        const output = child_process
+            .execSync("npm config get", {
+                cwd: npmConfigGetCwd
+            })
+            .toString("utf8");
+
+        return output
+            .split("\n")
+            .filter(line => !line.startsWith(";"))
+            .map(line => line.trim())
+            .map(line => {
+                const [key, value] = line.split("=");
+                if (key === undefined) {
+                    return undefined;
+                }
+                if (value === undefined) {
+                    return undefined;
+                }
+                return [key.trim(), value.trim()] as const;
+            })
+            .filter(exclude(undefined))
+            .filter(([key]) => key !== "")
+            .map(([key, value]) => {
+                if (value.startsWith('"') && value.endsWith('"')) {
+                    return [key, value.slice(1, -1)] as const;
+                }
 
-export async function getProxyFetchOptions(params: { npmWorkspaceRootDirPath: string }): Promise<ProxyFetchOptions> {
-    const { npmWorkspaceRootDirPath } = params;
+                if (value === "true" || value === "false") {
+                    return [key, value] as const;
+                }
 
-    const cfg = await getNmpConfig({ npmWorkspaceRootDirPath });
+                return undefined;
+            })
+            .filter(exclude(undefined))
+            .reduce(
+                (cfg: Record<string, string | string[]>, [key, value]) =>
+                    key in cfg
+                        ? { ...cfg, [key]: [...ensureArray(cfg[key]), value] }
+                        : { ...cfg, [key]: value },
+                {}
+            );
+    })();
 
     const proxy = ensureSingleOrNone(cfg["https-proxy"] ?? cfg["proxy"]);
+
     const noProxy = cfg["noproxy"] ?? cfg["no-proxy"];
 
-    function maybeBoolean(arg0: string | undefined) {
-        return typeof arg0 === "undefined" ? undefined : Boolean(arg0);
-    }
+    const strictSSL = ensureSingleOrNone(cfg["strict-ssl"]) === "true";
 
-    const strictSSL = maybeBoolean(ensureSingleOrNone(cfg["strict-ssl"]));
     const cert = cfg["cert"];
+
     const ca = ensureArray(cfg["ca"] ?? cfg["ca[]"]);
+
     const cafile = ensureSingleOrNone(cfg["cafile"]);
 
-    if (typeof cafile !== "undefined" && cafile !== "null") {
+    if (cafile !== undefined) {
         ca.push(
-            ...(await (async () => {
-                function chunks<T>(arr: T[], size: number = 2) {
-                    return arr.map((_, i) => i % size == 0 && arr.slice(i, i + size)).filter(Boolean) as T[][];
-                }
-
-                const cafileContent = await readFile(cafile, "utf-8");
-                return chunks(cafileContent.split(/(-----END CERTIFICATE-----)/), 2).map(ca => ca.join("").replace(/^\n/, "").replace(/\n/g, "\\n"));
-            })())
+            ...(() => {
+                const cafileContent = fs.readFileSync(cafile).toString("utf8");
+
+                const newLinePlaceholder = "NEW_LINE_PLACEHOLDER_xIsPsK23svt";
+
+                const chunks = <T>(arr: T[], size: number = 2) =>
+                    arr
+                        .map((_, i) => i % size == 0 && arr.slice(i, i + size))
+                        .filter(Boolean) as T[][];
+
+                return chunks(cafileContent.split(/(-----END CERTIFICATE-----)/), 2).map(
+                    ca =>
+                        ca
+                            .join("")
+                            .replace(/\r?\n/g, newLinePlaceholder)
+                            .replace(new RegExp(`^${newLinePlaceholder}`), "")
+                            .replace(new RegExp(newLinePlaceholder, "g"), "\\n")
+                );
+            })()
         );
     }
 
-    return { proxy, noProxy, strictSSL, cert, "ca": ca.length === 0 ? undefined : ca };
+    return {
+        proxy,
+        noProxy,
+        strictSSL,
+        cert,
+        ca: ca.length === 0 ? undefined : ca
+    };
+}
+
+function ensureArray<T>(arg0: T | T[]) {
+    return Array.isArray(arg0) ? arg0 : arg0 === undefined ? [] : [arg0];
+}
+
+function ensureSingleOrNone<T>(arg0: T | T[]) {
+    if (!Array.isArray(arg0)) return arg0;
+    if (arg0.length === 0) return undefined;
+    if (arg0.length === 1) return arg0[0];
+    throw new Error(
+        "Illegal configuration, expected a single value but found multiple: " +
+            arg0.map(String).join(", ")
+    );
 }

package/src/bin/tools/getAbsoluteAndInOsFormatPath.ts

@@ -1,7 +1,15 @@
-import { isAbsolute as pathIsAbsolute, sep as pathSep, join as pathJoin, resolve as pathResolve } from "path";
+import {
+    isAbsolute as pathIsAbsolute,
+    sep as pathSep,
+    join as pathJoin,
+    resolve as pathResolve
+} from "path";
 import * as os from "os";
 
-export function getAbsoluteAndInOsFormatPath(params: { pathIsh: string; cwd: string }): string {
+export function getAbsoluteAndInOsFormatPath(params: {
+    pathIsh: string;
+    cwd: string;
+}): string {
     const { pathIsh, cwd } = params;
 
     let pathOut = pathIsh;

package/src/bin/tools/npmInstall.ts

@@ -0,0 +1,63 @@
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+import * as child_process from "child_process";
+import chalk from "chalk";
+
+export function npmInstall(params: { packageJsonDirPath: string }) {
+    const { packageJsonDirPath } = params;
+
+    const packageManagerBinName = (() => {
+        const packageMangers = [
+            {
+                binName: "yarn",
+                lockFileBasename: "yarn.lock"
+            },
+            {
+                binName: "npm",
+                lockFileBasename: "package-lock.json"
+            },
+            {
+                binName: "pnpm",
+                lockFileBasename: "pnpm-lock.yaml"
+            },
+            {
+                binName: "bun",
+                lockFileBasename: "bun.lockdb"
+            }
+        ] as const;
+
+        for (const packageManager of packageMangers) {
+            if (
+                fs.existsSync(
+                    pathJoin(packageJsonDirPath, packageManager.lockFileBasename)
+                ) ||
+                fs.existsSync(pathJoin(process.cwd(), packageManager.lockFileBasename))
+            ) {
+                return packageManager.binName;
+            }
+        }
+
+        return undefined;
+    })();
+
+    install_dependencies: {
+        if (packageManagerBinName === undefined) {
+            break install_dependencies;
+        }
+
+        console.log(`Installing the new dependencies...`);
+
+        try {
+            child_process.execSync(`${packageManagerBinName} install`, {
+                cwd: packageJsonDirPath,
+                stdio: "inherit"
+            });
+        } catch {
+            console.log(
+                chalk.yellow(
+                    `\`${packageManagerBinName} install\` failed, continuing anyway...`
+                )
+            );
+        }
+    }
+}

package/src/bin/tools/octokit-addons/getLatestsSemVersionedTag.ts

@@ -5,13 +5,18 @@ import { SemVer } from "../SemVer";
 export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
     const { octokit } = params;
 
-    async function getLatestsSemVersionedTag(params: { owner: string; repo: string; count: number }): Promise<
+    async function getLatestsSemVersionedTag(params: {
+        owner: string;
+        repo: string;
+        count: number;
+        doIgnoreReleaseCandidates: boolean;
+    }): Promise<
         {
             tag: string;
             version: SemVer;
         }[]
     > {
-        const { owner, repo, count } = params;
+        const { owner, repo, count, doIgnoreReleaseCandidates } = params;
 
         const semVersionedTags: { tag: string; version: SemVer }[] = [];
 
@@ -26,14 +31,16 @@ export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
                 continue;
             }
 
-            if (version.rc !== undefined) {
+            if (doIgnoreReleaseCandidates && version.rc !== undefined) {
                 continue;
             }
 
             semVersionedTags.push({ tag, version });
         }
 
-        return semVersionedTags.sort(({ version: vX }, { version: vY }) => SemVer.compare(vY, vX)).slice(0, count);
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer.compare(vY, vX))
+            .slice(0, count);
     }
 
     return { getLatestsSemVersionedTag };

package/src/bin/tools/octokit-addons/listTags.ts

@@ -5,11 +5,19 @@ const per_page = 99;
 export function listTagsFactory(params: { octokit: Octokit }) {
     const { octokit } = params;
 
-    const octokit_repo_listTags = async (params: { owner: string; repo: string; per_page: number; page: number }) => {
+    const octokit_repo_listTags = async (params: {
+        owner: string;
+        repo: string;
+        per_page: number;
+        page: number;
+    }) => {
         return octokit.repos.listTags(params);
     };
 
-    async function* listTags(params: { owner: string; repo: string }): AsyncGenerator<string> {
+    async function* listTags(params: {
+        owner: string;
+        repo: string;
+    }): AsyncGenerator<string> {
         const { owner, repo } = params;
 
         let page = 1;
@@ -19,7 +27,7 @@ export function listTagsFactory(params: { octokit: Octokit }) {
                 owner,
                 repo,
                 per_page,
-                "page": page++
+                page: page++
             });
 
             for (const branch of resp.data.map(({ name }) => name)) {
@@ -33,7 +41,10 @@ export function listTagsFactory(params: { octokit: Octokit }) {
     }
 
     /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
-    async function getLatestTag(params: { owner: string; repo: string }): Promise<string | undefined> {
+    async function getLatestTag(params: {
+        owner: string;
+        repo: string;
+    }): Promise<string | undefined> {
         const { owner, repo } = params;
 
         const itRes = await listTags({ owner, repo }).next();

package/src/bin/tools/partitionPromiseSettledResults.ts

@@ -2,10 +2,19 @@ export type PromiseSettledAndPartitioned<T> = [T[], any[]];
 
 export function partitionPromiseSettledResults<T>() {
     return [
-        ([successes, failures]: PromiseSettledAndPartitioned<T>, item: PromiseSettledResult<T>) =>
+        (
+            [successes, failures]: PromiseSettledAndPartitioned<T>,
+            item: PromiseSettledResult<T>
+        ) =>
             item.status === "rejected"
-                ? ([successes, [item.reason, ...failures]] as PromiseSettledAndPartitioned<T>)
-                : ([[item.value, ...successes], failures] as PromiseSettledAndPartitioned<T>),
+                ? ([
+                      successes,
+                      [item.reason, ...failures]
+                  ] as PromiseSettledAndPartitioned<T>)
+                : ([
+                      [item.value, ...successes],
+                      failures
+                  ] as PromiseSettledAndPartitioned<T>),
         [[], []] as PromiseSettledAndPartitioned<T>
     ] as const;
 }

package/src/bin/tools/readThisNpmPackageVersion.ts

@@ -4,7 +4,11 @@ import * as fs from "fs";
 import { join as pathJoin } from "path";
 
 export function readThisNpmPackageVersion(): string {
-    const version = JSON.parse(fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json")).toString("utf8"))["version"];
+    const version = JSON.parse(
+        fs
+            .readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json"))
+            .toString("utf8")
+    )["version"];
 
     assert(typeof version === "string");
 

package/src/bin/tools/transformCodebase.ts

@@ -3,7 +3,11 @@ import * as path from "path";
 import { crawl } from "./crawl";
 import { rmSync } from "../tools/fs.rmSync";
 
-type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) =>
+type TransformSourceCode = (params: {
+    sourceCode: Buffer;
+    filePath: string;
+    fileRelativePath: string;
+}) =>
     | {
           modifiedSourceCode: Buffer;
           newFileName?: string;
@@ -15,18 +19,27 @@ type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; file
  * If source and destination are the same this function can be used to apply the transformation in place
  * like filtering out some files or modifying them.
  * */
-export function transformCodebase(params: { srcDirPath: string; destDirPath: string; transformSourceCode?: TransformSourceCode }) {
+export function transformCodebase(params: {
+    srcDirPath: string;
+    destDirPath: string;
+    transformSourceCode?: TransformSourceCode;
+}) {
     const { srcDirPath, transformSourceCode } = params;
 
     const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === "";
 
-    const destDirPath = isTargetSameAsSource ? path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs") : params.destDirPath;
+    const destDirPath = isTargetSameAsSource
+        ? path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs")
+        : params.destDirPath;
 
     fs.mkdirSync(destDirPath, {
-        "recursive": true
+        recursive: true
     });
 
-    for (const fileRelativePath of crawl({ "dirPath": srcDirPath, "returnedPathsType": "relative to dirPath" })) {
+    for (const fileRelativePath of crawl({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })) {
         const filePath = path.join(srcDirPath, fileRelativePath);
         const destFilePath = path.join(destDirPath, fileRelativePath);
 
@@ -34,7 +47,7 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         // it using the lower level implementation.
         if (transformSourceCode === undefined) {
             fs.mkdirSync(path.dirname(destFilePath), {
-                "recursive": true
+                recursive: true
             });
 
             fs.copyFileSync(filePath, destFilePath);
@@ -43,7 +56,7 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }
 
         const transformSourceCodeResult = transformSourceCode({
-            "sourceCode": fs.readFileSync(filePath),
+            sourceCode: fs.readFileSync(filePath),
             filePath,
             fileRelativePath
         });
@@ -53,16 +66,22 @@ export function transformCodebase(params: { srcDirPath: string; destDirPath: str
         }
 
         fs.mkdirSync(path.dirname(destFilePath), {
-            "recursive": true
+            recursive: true
         });
 
         const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
 
-        fs.writeFileSync(path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)), modifiedSourceCode);
+        fs.writeFileSync(
+            path.join(
+                path.dirname(destFilePath),
+                newFileName ?? path.basename(destFilePath)
+            ),
+            modifiedSourceCode
+        );
     }
 
     if (isTargetSameAsSource) {
-        rmSync(srcDirPath, { "recursive": true });
+        rmSync(srcDirPath, { recursive: true });
 
         fs.renameSync(destDirPath, srcDirPath);
     }

package/src/bin/tools/trimIndent.ts

@@ -14,7 +14,10 @@ function populateTemplate(strings: TemplateStringsArray, ...args: unknown[]) {
         if (args[i]) {
             // if the interpolation value has newlines, indent the interpolation values
             // using the last known string indent
-            const chunk = String(args[i]).replace(/([\r?\n])/g, "$1" + " ".repeat(lastStringLineLength));
+            const chunk = String(args[i]).replace(
+                /([\r?\n])/g,
+                "$1" + " ".repeat(lastStringLineLength)
+            );
             chunks.push(chunk);
         }
     }

package/src/bin/tsconfig.json

@@ -1,11 +1,14 @@
 {
     "extends": "../../tsproject.json",
     "compilerOptions": {
-        "module": "CommonJS",
-        "target": "ES5",
+        "module": "ES2020",
+        "target": "ES2017",
         "esModuleInterop": true,
-        "lib": ["es2015", "DOM", "ES2019.Object"],
+        "lib": ["es2015", "ES2019.Object"],
+        "moduleResolution": "node",
         "outDir": "../../dist/bin",
         "rootDir": "."
-    }
+    },
+    "include": ["**/*.ts", "**/*.tsx"],
+    "exclude": ["initialize-account-theme/src"]
 }

package/src/bin/update-kc-gen.ts

@@ -0,0 +1,13 @@
+import type { CliCommandOptions } from "./main";
+import { getBuildContext } from "./shared/buildContext";
+import { generateKcGenTs } from "./shared/generateKcGenTs";
+
+export async function command(params: { cliCommandOptions: CliCommandOptions }) {
+    const { cliCommandOptions } = params;
+
+    const buildContext = getBuildContext({
+        cliCommandOptions
+    });
+
+    await generateKcGenTs({ buildContext });
+}

package/src/lib/getKcClsx.ts

@@ -0,0 +1,89 @@
+import type { Param0 } from "tsafe";
+import { type CxArg, clsx_withTransform } from "../tools/clsx_withTransform";
+import { clsx } from "../tools/clsx";
+import { assert } from "tsafe/assert";
+import { is } from "tsafe/is";
+
+export function createGetKcClsx<ClassKey extends string>(params: {
+    defaultClasses: Record<ClassKey, string | undefined>;
+}) {
+    const { defaultClasses } = params;
+
+    function areSameParams(
+        params1: Param0<typeof getKcClsx>,
+        params2: Param0<typeof getKcClsx>
+    ): boolean {
+        if (params1.doUseDefaultCss !== params2.doUseDefaultCss) {
+            return false;
+        }
+
+        if (params1.classes === params2.classes) {
+            return true;
+        }
+
+        if (params1.classes === undefined || params2.classes === undefined) {
+            return false;
+        }
+
+        if (Object.keys(params1.classes).length !== Object.keys(params2.classes).length) {
+            return false;
+        }
+
+        for (const key in params1.classes) {
+            if (params1.classes[key] !== params2.classes[key]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    let cache:
+        | {
+              params: Param0<typeof getKcClsx>;
+              result: ReturnType<typeof getKcClsx>;
+          }
+        | undefined = undefined;
+
+    function getKcClsx(params: {
+        doUseDefaultCss: boolean;
+        classes: Partial<Record<ClassKey, string>> | undefined;
+    }): { kcClsx: (...args: CxArg<ClassKey>[]) => string } {
+        // NOTE: We implement a cache here only so that getClassName can be stable across renders.
+        // We don't want to use useConstCallback because we want this to be useable outside of React.
+        use_cache: {
+            if (cache === undefined) {
+                break use_cache;
+            }
+
+            if (!areSameParams(cache.params, params)) {
+                break use_cache;
+            }
+
+            return cache.result;
+        }
+
+        const { classes, doUseDefaultCss } = params;
+
+        function kcClsx(...args: CxArg<ClassKey>[]): string {
+            return clsx_withTransform({
+                args,
+                transform: classKey => {
+                    assert(is<ClassKey>(classKey));
+
+                    return clsx(
+                        classKey,
+                        classes?.[classKey] ??
+                            (doUseDefaultCss ? defaultClasses[classKey] : undefined)
+                    );
+                }
+            });
+        }
+
+        cache = { params, result: { kcClsx } };
+
+        return { kcClsx };
+    }
+
+    return { getKcClsx };
+}

package/src/login/{Fallback.tsx → DefaultPage.tsx}

@@ -1,10 +1,10 @@
 import { lazy, Suspense } from "react";
-import type { PageProps } from "keycloakify/login/pages/PageProps";
 import { assert, type Equals } from "tsafe/assert";
-import type { I18n } from "./i18n";
-import type { KcContext } from "./kcContext";
 import type { LazyOrNot } from "keycloakify/tools/LazyOrNot";
-import type { UserProfileFormFieldsProps } from "keycloakify/login/UserProfileFormFields";
+import type { PageProps } from "keycloakify/login/pages/PageProps";
+import type { I18n } from "keycloakify/login/i18n";
+import type { KcContext } from "keycloakify/login/KcContext";
+import type { UserProfileFormFieldsProps } from "keycloakify/login/UserProfileFormFieldsProps";
 
 const Login = lazy(() => import("keycloakify/login/pages/Login"));
 const Register = lazy(() => import("keycloakify/login/pages/Register"));
@@ -41,11 +41,12 @@ const LoginResetOtp = lazy(() => import("keycloakify/login/pages/LoginResetOtp")
 const LoginX509Info = lazy(() => import("keycloakify/login/pages/LoginX509Info"));
 const WebauthnError = lazy(() => import("keycloakify/login/pages/WebauthnError"));
 
-type FallbackProps = PageProps<KcContext, I18n> & {
+type DefaultPageProps = PageProps<KcContext, I18n> & {
     UserProfileFormFields: LazyOrNot<(props: UserProfileFormFieldsProps) => JSX.Element>;
+    doMakeUserConfirmPassword: boolean;
 };
 
-export default function Fallback(props: FallbackProps) {
+export default function DefaultPage(props: DefaultPageProps) {
     const { kcContext, ...rest } = props;
 
     return (