keycloakify 10.0.0-rc.2 → 10.0.0-rc.21

package/src/bin/tools/fs.rmSync.ts

@@ -20,13 +20,13 @@ export function rmSync(dirPath: string, options: { recursive: true; force?: true
 
     const removeDir_rec = (dirPath: string) =>
         fs.readdirSync(dirPath).forEach(basename => {
-            const fileOrDirpath = pathJoin(dirPath, basename);
+            const fileOrDirPath = pathJoin(dirPath, basename);
 
-            if (fs.lstatSync(fileOrDirpath).isDirectory()) {
-                removeDir_rec(fileOrDirpath);
+            if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+                removeDir_rec(fileOrDirPath);
                 return;
             } else {
-                fs.unlinkSync(fileOrDirpath);
+                fs.unlinkSync(fileOrDirPath);
             }
         });
 

package/src/bin/tools/getAbsoluteAndInOsFormatPath.ts

@@ -1,17 +1,32 @@
-import { isAbsolute as pathIsAbsolute, sep as pathSep, join as pathJoin } 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;
 
     pathOut = pathOut.replace(/\//g, pathSep);
 
+    if (pathOut.startsWith("~")) {
+        pathOut = pathOut.replace("~", os.homedir());
+    }
+
     pathOut = pathOut.endsWith(pathSep) ? pathOut.slice(0, -1) : pathOut;
 
     if (!pathIsAbsolute(pathOut)) {
         pathOut = pathJoin(cwd, pathOut);
     }
 
+    pathOut = pathResolve(pathOut);
+
     return pathOut;
 }

package/src/bin/tools/getNpmWorkspaceRootDirPath.ts

@@ -0,0 +1,73 @@
+import * as child_process from "child_process";
+import { join as pathJoin, resolve as pathResolve, sep as pathSep } from "path";
+import { assert } from "tsafe/assert";
+import * as fs from "fs";
+
+export function getNpmWorkspaceRootDirPath(params: {
+    reactAppRootDirPath: string;
+    dependencyExpected: string;
+}) {
+    const { reactAppRootDirPath, dependencyExpected } = params;
+
+    const npmWorkspaceRootDirPath = (function callee(depth: number): string {
+        const cwd = pathResolve(
+            pathJoin(...[reactAppRootDirPath, ...Array(depth).fill("..")])
+        );
+
+        try {
+            child_process.execSync("npm config get", {
+                cwd,
+                stdio: "ignore"
+            });
+        } catch (error) {
+            if (String(error).includes("ENOWORKSPACES")) {
+                assert(cwd !== pathSep, "NPM workspace not found");
+
+                return callee(depth + 1);
+            }
+
+            throw error;
+        }
+
+        const { isExpectedDependencyFound } = (() => {
+            const packageJsonFilePath = pathJoin(cwd, "package.json");
+
+            assert(fs.existsSync(packageJsonFilePath));
+
+            const parsedPackageJson = JSON.parse(
+                fs.readFileSync(packageJsonFilePath).toString("utf8")
+            );
+
+            let isExpectedDependencyFound = false;
+
+            for (const dependenciesOrDevDependencies of [
+                "dependencies",
+                "devDependencies"
+            ] as const) {
+                const dependencies = parsedPackageJson[dependenciesOrDevDependencies];
+
+                if (dependencies === undefined) {
+                    continue;
+                }
+
+                assert(dependencies instanceof Object);
+
+                if (dependencies[dependencyExpected] === undefined) {
+                    continue;
+                }
+
+                isExpectedDependencyFound = true;
+            }
+
+            return { isExpectedDependencyFound };
+        })();
+
+        if (!isExpectedDependencyFound) {
+            return callee(depth + 1);
+        }
+
+        return cwd;
+    })(0);
+
+    return { npmWorkspaceRootDirPath };
+}

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

@@ -5,7 +5,11 @@ 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;
+    }): Promise<
         {
             tag: string;
             version: SemVer;
@@ -33,7 +37,9 @@ export function getLatestsSemVersionedTagFactory(params: { octokit: Octokit }) {
             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/{readThisNpmProjectVersion.ts → readThisNpmPackageVersion.ts}

@@ -3,8 +3,12 @@ import { assert } from "tsafe/assert";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
 
-export function readThisNpmProjectVersion(): string {
-    const version = JSON.parse(fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json")).toString("utf8"))["version"];
+export function readThisNpmPackageVersion(): string {
+    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/lib/isStorybook.ts

@@ -1 +1,3 @@
-export const isStorybook = typeof window === "object" && Object.keys(window).find(key => key.startsWith("__STORYBOOK")) !== undefined;
+export const isStorybook =
+    typeof window === "object" &&
+    Object.keys(window).find(key => key.startsWith("__STORYBOOK")) !== undefined;

package/src/lib/useGetClassName.ts

@@ -1,14 +1,23 @@
 import { clsx } from "keycloakify/tools/clsx";
 import { useConstCallback } from "keycloakify/tools/useConstCallback";
 
-export function createUseClassName<ClassKey extends string>(params: { defaultClasses: Record<ClassKey, string | undefined> }) {
+export function createUseClassName<ClassKey extends string>(params: {
+    defaultClasses: Record<ClassKey, string | undefined>;
+}) {
     const { defaultClasses } = params;
 
-    function useGetClassName(params: { doUseDefaultCss: boolean; classes: Partial<Record<ClassKey, string>> | undefined }) {
+    function useGetClassName(params: {
+        doUseDefaultCss: boolean;
+        classes: Partial<Record<ClassKey, string>> | undefined;
+    }) {
         const { classes, doUseDefaultCss } = params;
 
         const getClassName = useConstCallback((classKey: ClassKey): string => {
-            return clsx(classKey, doUseDefaultCss ? defaultClasses[classKey] : undefined, classes?.[classKey]);
+            return clsx(
+                classKey,
+                doUseDefaultCss ? defaultClasses[classKey] : undefined,
+                classes?.[classKey]
+            );
         });
 
         return { getClassName };

package/src/login/Template.tsx

@@ -32,7 +32,7 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
 
     const { getClassName } = useGetClassName({ doUseDefaultCss, classes });
 
-    const { msg, msgStr, changeLocale, labelBySupportedLanguageTag, currentLanguageTag } = i18n;
+    const { msg, msgStr, getChangeLocalUrl, labelBySupportedLanguageTag, currentLanguageTag } = i18n;
 
     const { realm, locale, auth, url, message, isAppInitiatedAction, authenticationSession, scripts } = kcContext;
 
@@ -41,13 +41,13 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
     }, []);
 
     useSetClassName({
-        "qualifiedName": "html",
-        "className": getClassName("kcHtmlClass")
+        qualifiedName: "html",
+        className: getClassName("kcHtmlClass")
     });
 
     useSetClassName({
-        "qualifiedName": "body",
-        "className": bodyClassName ?? getClassName("kcBodyClass")
+        qualifiedName: "body",
+        className: bodyClassName ?? getClassName("kcBodyClass")
     });
 
     useEffect(() => {
@@ -63,7 +63,7 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
     }, []);
 
     const { areAllStyleSheetsLoaded } = useInsertLinkTags({
-        "hrefs": !doUseDefaultCss
+        hrefs: !doUseDefaultCss
             ? []
             : [
                   `${url.resourcesCommonPath}/node_modules/@patternfly/patternfly/patternfly.min.css`,
@@ -75,17 +75,17 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
     });
 
     const { insertScriptTags } = useInsertScriptTags({
-        "scriptTags": [
+        scriptTags: [
             {
-                "type": "module",
-                "src": `${url.resourcesPath}/js/menu-button-links.js`
+                type: "module",
+                src: `${url.resourcesPath}/js/menu-button-links.js`
             },
             ...(authenticationSession === undefined
                 ? []
                 : [
                       {
-                          "type": "module",
-                          "textContent": [
+                          type: "module",
+                          textContent: [
                               `import { checkCookiesAndSetTimer } from "${url.resourcesPath}/js/authChecker.js";`,
                               ``,
                               `checkCookiesAndSetTimer(`,
@@ -99,9 +99,9 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
             ...scripts.map(
                 script =>
                     ({
-                        "type": "text/javascript",
-                        "src": script
-                    } as const)
+                        type: "text/javascript",
+                        src: script
+                    }) as const
             )
         ]
     });
@@ -126,31 +126,17 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
 
             <div className={getClassName("kcFormCardClass")}>
                 <header className={getClassName("kcFormHeaderClass")}>
-                    {realm.internationalizationEnabled && (assert(locale !== undefined), true) && locale.supported.length > 1 && (
+                    {realm.internationalizationEnabled && (assert(locale !== undefined), locale.supported.length > 1) && (
                         <div className={getClassName("kcLocaleMainClass")} id="kc-locale">
                             <div id="kc-locale-wrapper" className={getClassName("kcLocaleWrapperClass")}>
                                 <div id="kc-locale-dropdown" className={clsx("menu-button-links", getClassName("kcLocaleDropDownClass"))}>
                                     {/* eslint-disable-next-line jsx-a11y/anchor-is-valid */}
-                                    <a href="#" id="kc-current-locale-link">
-                                        {labelBySupportedLanguageTag[currentLanguageTag]}
-                                    </a>
-                                    <ul>
-                                        {locale.supported.map(({ languageTag }) => (
-                                            <li key={languageTag} className="kc-dropdown-item">
-                                                {/* eslint-disable-next-line jsx-a11y/anchor-is-valid */}
-                                                <a href="#" onClick={() => changeLocale(languageTag)}>
-                                                    {labelBySupportedLanguageTag[languageTag]}
-                                                </a>
-                                            </li>
-                                        ))}
-                                    </ul>
-
                                     <button
                                         tabIndex={1}
                                         id="kc-current-locale-link"
                                         aria-label={msgStr("languages" as any)}
-                                        aria-haspopup={true}
-                                        aria-expanded={false}
+                                        aria-haspopup="true"
+                                        aria-expanded="false"
                                         aria-controls="language-switch1"
                                     >
                                         {labelBySupportedLanguageTag[currentLanguageTag]}
@@ -165,13 +151,11 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
                                     >
                                         {locale.supported.map(({ languageTag }, i) => (
                                             <li key={languageTag} className={getClassName("kcLocaleListItemClass")} role="none">
-                                                {/* eslint-disable-next-line jsx-a11y/anchor-is-valid */}
                                                 <a
                                                     role="menuitem"
-                                                    id={`language-${i}`}
+                                                    id={`language-${i + 1}`}
                                                     className={getClassName("kcLocaleItemClass")}
-                                                    href="#"
-                                                    onClick={() => changeLocale(languageTag)}
+                                                    href={getChangeLocalUrl(languageTag)}
                                                 >
                                                     {labelBySupportedLanguageTag[languageTag]}
                                                 </a>
@@ -253,7 +237,7 @@ export default function Template(props: TemplateProps<KcContext, I18n>) {
                                 <span
                                     className={getClassName("kcAlertTitleClass")}
                                     dangerouslySetInnerHTML={{
-                                        "__html": message.summary
+                                        __html: message.summary
                                     }}
                                 />
                             </div>

package/src/login/TemplateProps.ts

@@ -2,7 +2,10 @@ import type { ReactNode } from "react";
 import type { KcContext } from "./kcContext";
 import type { I18n } from "./i18n";
 
-export type TemplateProps<KcContext extends KcContext.Common, I18nExtended extends I18n> = {
+export type TemplateProps<
+    KcContext extends KcContext.Common,
+    I18nExtended extends I18n
+> = {
     kcContext: KcContext;
     i18n: I18nExtended;
     doUseDefaultCss: boolean;