keycloakify 9.6.6 → 10.0.0-rc.0

package/src/lib/usePrepareTemplate.ts

@@ -1,113 +0,0 @@
-import { useReducer, useEffect } from "react";
-import { headInsert } from "keycloakify/tools/headInsert";
-import { clsx } from "keycloakify/tools/clsx";
-import { assert } from "tsafe/assert";
-
-export function usePrepareTemplate(params: {
-    doFetchDefaultThemeResources: boolean;
-    styles?: string[];
-    scripts?: string[];
-    htmlClassName: string | undefined;
-    bodyClassName: string | undefined;
-    htmlLangProperty?: string | undefined;
-    documentTitle?: string;
-}) {
-    const { doFetchDefaultThemeResources, styles = [], scripts = [], htmlClassName, bodyClassName, htmlLangProperty, documentTitle } = params;
-
-    const [isReady, setReady] = useReducer(() => true, !doFetchDefaultThemeResources);
-
-    useEffect(() => {
-        if (htmlLangProperty === undefined) {
-            return;
-        }
-
-        const html = document.querySelector("html");
-        assert(html !== null);
-        html.lang = htmlLangProperty;
-    }, [htmlLangProperty]);
-
-    useEffect(() => {
-        if (documentTitle === undefined) {
-            return;
-        }
-
-        document.title = documentTitle;
-    }, [documentTitle]);
-
-    useEffect(() => {
-        if (!doFetchDefaultThemeResources) {
-            return;
-        }
-
-        let isUnmounted = false;
-
-        const removeArray: (() => void)[] = [];
-
-        (async () => {
-            for (const style of [...styles].reverse()) {
-                const { prLoaded, remove } = headInsert({
-                    "type": "css",
-                    "position": "prepend",
-                    "href": style
-                });
-
-                removeArray.push(remove);
-
-                // TODO: Find a way to do that in parallel (without breaking the order)
-                await prLoaded;
-
-                if (isUnmounted) {
-                    return;
-                }
-            }
-
-            setReady();
-        })();
-
-        scripts.forEach(src => {
-            const { remove } = headInsert({
-                "type": "javascript",
-                src
-            });
-
-            removeArray.push(remove);
-        });
-
-        return () => {
-            isUnmounted = true;
-            removeArray.forEach(remove => remove());
-        };
-    }, []);
-
-    useSetClassName({
-        "target": "html",
-        "className": htmlClassName
-    });
-
-    useSetClassName({
-        "target": "body",
-        "className": bodyClassName
-    });
-
-    return { isReady };
-}
-
-function useSetClassName(params: { target: "html" | "body"; className: string | undefined }) {
-    const { target, className } = params;
-
-    useEffect(() => {
-        if (className === undefined) {
-            return;
-        }
-
-        const htmlClassList = document.getElementsByTagName(target)[0].classList;
-
-        const tokens = clsx(className).split(" ");
-
-        htmlClassList.add(...tokens);
-
-        return () => {
-            htmlClassList.remove(...tokens);
-        };
-    }, [className]);
-}

package/src/login/lib/useFormValidation.tsx

@@ -1,474 +0,0 @@
-import "keycloakify/tools/Array.prototype.every";
-import { useMemo, useReducer, Fragment } from "react";
-import { id } from "tsafe/id";
-import type { MessageKey } from "keycloakify/login/i18n/i18n";
-import type { Attribute, Validators } from "keycloakify/login/kcContext/KcContext";
-import { useConstCallback } from "keycloakify/tools/useConstCallback";
-import { emailRegexp } from "keycloakify/tools/emailRegExp";
-import type { KcContext } from "../kcContext";
-import type { I18n } from "../i18n";
-
-/**
- * NOTE: The attributesWithPassword returned is actually augmented with
- * artificial password related attributes only if kcContext.passwordRequired === true
- */
-export function useFormValidation(params: {
-    kcContext: {
-        messagesPerField: Pick<KcContext.Common["messagesPerField"], "existsError" | "get">;
-        profile: {
-            attributes: Attribute[];
-        };
-        passwordRequired?: boolean;
-        realm: { registrationEmailAsUsername: boolean };
-    };
-    /** NOTE: Try to avoid passing a new ref every render for better performances. */
-    passwordValidators?: Validators;
-    i18n: I18n;
-}) {
-    const { kcContext, passwordValidators = {}, i18n } = params;
-
-    const attributesWithPassword = useMemo(
-        () =>
-            !kcContext.passwordRequired
-                ? kcContext.profile.attributes
-                : (() => {
-                      const name = kcContext.realm.registrationEmailAsUsername ? "email" : "username";
-
-                      return kcContext.profile.attributes.reduce<Attribute[]>(
-                          (prev, curr) => [
-                              ...prev,
-                              ...(curr.name !== name
-                                  ? [curr]
-                                  : [
-                                        curr,
-                                        id<Attribute>({
-                                            "name": "password",
-                                            "displayName": id<`\${${MessageKey}}`>("${password}"),
-                                            "required": true,
-                                            "readOnly": false,
-                                            "validators": passwordValidators,
-                                            "annotations": {},
-                                            "groupAnnotations": {},
-                                            "autocomplete": "new-password"
-                                        }),
-                                        id<Attribute>({
-                                            "name": "password-confirm",
-                                            "displayName": id<`\${${MessageKey}}`>("${passwordConfirm}"),
-                                            "required": true,
-                                            "readOnly": false,
-                                            "validators": {
-                                                "_compareToOther": {
-                                                    "name": "password",
-                                                    "ignore.empty.value": true,
-                                                    "shouldBe": "equal",
-                                                    "error-message": id<`\${${MessageKey}}`>("${invalidPasswordConfirmMessage}")
-                                                }
-                                            },
-                                            "annotations": {},
-                                            "groupAnnotations": {},
-                                            "autocomplete": "new-password"
-                                        })
-                                    ])
-                          ],
-                          []
-                      );
-                  })(),
-        [kcContext, passwordValidators]
-    );
-
-    const { getErrors } = useGetErrors({
-        "kcContext": {
-            "messagesPerField": kcContext.messagesPerField,
-            "profile": {
-                "attributes": attributesWithPassword
-            }
-        },
-        i18n
-    });
-
-    const initialInternalState = useMemo(
-        () =>
-            Object.fromEntries(
-                attributesWithPassword
-                    .map(attribute => ({
-                        attribute,
-                        "errors": getErrors({
-                            "name": attribute.name,
-                            "fieldValueByAttributeName": Object.fromEntries(
-                                attributesWithPassword.map(({ name, value }) => [name, { "value": value ?? "" }])
-                            )
-                        })
-                    }))
-                    .map(({ attribute, errors }) => [
-                        attribute.name,
-                        {
-                            "value": attribute.value ?? "",
-                            errors,
-                            "doDisplayPotentialErrorMessages": errors.length !== 0
-                        }
-                    ])
-            ),
-        [attributesWithPassword]
-    );
-
-    type InternalState = typeof initialInternalState;
-
-    const [formValidationInternalState, formValidationDispatch] = useReducer(
-        (
-            state: InternalState,
-            params:
-                | {
-                      action: "update value";
-                      name: string;
-                      newValue: string;
-                  }
-                | {
-                      action: "focus lost";
-                      name: string;
-                  }
-        ): InternalState => ({
-            ...state,
-            [params.name]: {
-                ...state[params.name],
-                ...(() => {
-                    switch (params.action) {
-                        case "focus lost":
-                            return { "doDisplayPotentialErrorMessages": true };
-                        case "update value":
-                            return {
-                                "value": params.newValue,
-                                "errors": getErrors({
-                                    "name": params.name,
-                                    "fieldValueByAttributeName": {
-                                        ...state,
-                                        [params.name]: { "value": params.newValue }
-                                    }
-                                })
-                            };
-                    }
-                })()
-            }
-        }),
-        initialInternalState
-    );
-
-    const formValidationState = useMemo(
-        () => ({
-            "fieldStateByAttributeName": Object.fromEntries(
-                Object.entries(formValidationInternalState).map(([name, { value, errors, doDisplayPotentialErrorMessages }]) => [
-                    name,
-                    { value, "displayableErrors": doDisplayPotentialErrorMessages ? errors : [] }
-                ])
-            ),
-            "isFormSubmittable": Object.entries(formValidationInternalState).every(
-                ([name, { value, errors }]) =>
-                    errors.length === 0 && (value !== "" || !attributesWithPassword.find(attribute => attribute.name === name)!.required)
-            )
-        }),
-        [formValidationInternalState, attributesWithPassword]
-    );
-
-    return {
-        formValidationState,
-        formValidationDispatch,
-        attributesWithPassword
-    };
-}
-
-/** Expect to be used in a component wrapped within a <I18nProvider> */
-function useGetErrors(params: {
-    kcContext: {
-        messagesPerField: Pick<KcContext.Common["messagesPerField"], "existsError" | "get">;
-        profile: {
-            attributes: { name: string; value?: string; validators: Validators }[];
-        };
-    };
-    i18n: I18n;
-}) {
-    const { kcContext, i18n } = params;
-
-    const {
-        messagesPerField,
-        profile: { attributes }
-    } = kcContext;
-
-    const { msg, msgStr, advancedMsg, advancedMsgStr } = i18n;
-
-    const getErrors = useConstCallback((params: { name: string; fieldValueByAttributeName: Record<string, { value: string }> }) => {
-        const { name, fieldValueByAttributeName } = params;
-
-        const { value } = fieldValueByAttributeName[name];
-
-        const { value: defaultValue, validators } = attributes.find(attribute => attribute.name === name)!;
-
-        block: {
-            if ((defaultValue ?? "") !== value) {
-                break block;
-            }
-
-            let doesErrorExist: boolean;
-
-            try {
-                doesErrorExist = messagesPerField.existsError(name);
-            } catch {
-                break block;
-            }
-
-            if (!doesErrorExist) {
-                break block;
-            }
-
-            const errorMessageStr = messagesPerField.get(name);
-
-            return [
-                {
-                    "validatorName": undefined,
-                    errorMessageStr,
-                    "errorMessage": <span key={0}>{errorMessageStr}</span>
-                }
-            ];
-        }
-
-        const errors: {
-            errorMessage: JSX.Element;
-            errorMessageStr: string;
-            validatorName: keyof Validators | undefined;
-        }[] = [];
-
-        scope: {
-            const validatorName = "length";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            const { "ignore.empty.value": ignoreEmptyValue = false, max, min } = validator;
-
-            if (ignoreEmptyValue && value === "") {
-                break scope;
-            }
-
-            if (max !== undefined && value.length > parseInt(max)) {
-                const msgArgs = ["error-invalid-length-too-long", max] as const;
-
-                errors.push({
-                    "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                    "errorMessageStr": msgStr(...msgArgs),
-                    validatorName
-                });
-            }
-
-            if (min !== undefined && value.length < parseInt(min)) {
-                const msgArgs = ["error-invalid-length-too-short", min] as const;
-
-                errors.push({
-                    "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                    "errorMessageStr": msgStr(...msgArgs),
-                    validatorName
-                });
-            }
-        }
-
-        scope: {
-            const validatorName = "_compareToOther";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            const { "ignore.empty.value": ignoreEmptyValue = false, name: otherName, shouldBe, "error-message": errorMessageKey } = validator;
-
-            if (ignoreEmptyValue && value === "") {
-                break scope;
-            }
-
-            const { value: otherValue } = fieldValueByAttributeName[otherName];
-
-            const isValid = (() => {
-                switch (shouldBe) {
-                    case "different":
-                        return otherValue !== value;
-                    case "equal":
-                        return otherValue === value;
-                }
-            })();
-
-            if (isValid) {
-                break scope;
-            }
-
-            const msgArg = [
-                errorMessageKey ??
-                    id<MessageKey>(
-                        (() => {
-                            switch (shouldBe) {
-                                case "equal":
-                                    return "shouldBeEqual";
-                                case "different":
-                                    return "shouldBeDifferent";
-                            }
-                        })()
-                    ),
-                otherName,
-                name,
-                shouldBe
-            ] as const;
-
-            errors.push({
-                validatorName,
-                "errorMessage": <Fragment key={errors.length}>{advancedMsg(...msgArg)}</Fragment>,
-                "errorMessageStr": advancedMsgStr(...msgArg)
-            });
-        }
-
-        scope: {
-            const validatorName = "pattern";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            const { "ignore.empty.value": ignoreEmptyValue = false, pattern, "error-message": errorMessageKey } = validator;
-
-            if (ignoreEmptyValue && value === "") {
-                break scope;
-            }
-
-            if (new RegExp(pattern).test(value)) {
-                break scope;
-            }
-
-            const msgArgs = [errorMessageKey ?? id<MessageKey>("shouldMatchPattern"), pattern] as const;
-
-            errors.push({
-                validatorName,
-                "errorMessage": <Fragment key={errors.length}>{advancedMsg(...msgArgs)}</Fragment>,
-                "errorMessageStr": advancedMsgStr(...msgArgs)
-            });
-        }
-
-        scope: {
-            if ([...errors].reverse()[0]?.validatorName === "pattern") {
-                break scope;
-            }
-
-            const validatorName = "email";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            const { "ignore.empty.value": ignoreEmptyValue = false } = validator;
-
-            if (ignoreEmptyValue && value === "") {
-                break scope;
-            }
-
-            if (emailRegexp.test(value)) {
-                break scope;
-            }
-
-            const msgArgs = [id<MessageKey>("invalidEmailMessage")] as const;
-
-            errors.push({
-                validatorName,
-                "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                "errorMessageStr": msgStr(...msgArgs)
-            });
-        }
-
-        scope: {
-            const validatorName = "integer";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            const { "ignore.empty.value": ignoreEmptyValue = false, max, min } = validator;
-
-            if (ignoreEmptyValue && value === "") {
-                break scope;
-            }
-
-            const intValue = parseInt(value);
-
-            if (isNaN(intValue)) {
-                const msgArgs = ["mustBeAnInteger"] as const;
-
-                errors.push({
-                    validatorName,
-                    "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                    "errorMessageStr": msgStr(...msgArgs)
-                });
-
-                break scope;
-            }
-
-            if (max !== undefined && intValue > parseInt(max)) {
-                const msgArgs = ["error-number-out-of-range-too-big", max] as const;
-
-                errors.push({
-                    validatorName,
-                    "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                    "errorMessageStr": msgStr(...msgArgs)
-                });
-
-                break scope;
-            }
-
-            if (min !== undefined && intValue < parseInt(min)) {
-                const msgArgs = ["error-number-out-of-range-too-small", min] as const;
-
-                errors.push({
-                    validatorName,
-                    "errorMessage": <Fragment key={errors.length}>{msg(...msgArgs)}</Fragment>,
-                    "errorMessageStr": msgStr(...msgArgs)
-                });
-
-                break scope;
-            }
-        }
-
-        scope: {
-            const validatorName = "options";
-
-            const validator = validators[validatorName];
-
-            if (validator === undefined) {
-                break scope;
-            }
-
-            if (value === "") {
-                break scope;
-            }
-
-            if (validator.options.indexOf(value) >= 0) {
-                break scope;
-            }
-
-            const msgArgs = [id<MessageKey>("notAValidOption")] as const;
-
-            errors.push({
-                validatorName,
-                "errorMessage": <Fragment key={errors.length}>{advancedMsg(...msgArgs)}</Fragment>,
-                "errorMessageStr": advancedMsgStr(...msgArgs)
-            });
-        }
-
-        //TODO: Implement missing validators.
-
-        return errors;
-    });
-
-    return { getErrors };
-}

package/src/login/pages/RegisterUserProfile.tsx

@@ -1,72 +0,0 @@
-import { useState } from "react";
-import { clsx } from "keycloakify/tools/clsx";
-import { UserProfileFormFields } from "./shared/UserProfileFormFields";
-import type { PageProps } from "keycloakify/login/pages/PageProps";
-import { useGetClassName } from "keycloakify/login/lib/useGetClassName";
-import type { KcContext } from "../kcContext";
-import type { I18n } from "../i18n";
-
-export default function RegisterUserProfile(props: PageProps<Extract<KcContext, { pageId: "register-user-profile.ftl" }>, I18n>) {
-    const { kcContext, i18n, doUseDefaultCss, Template, classes } = props;
-
-    const { getClassName } = useGetClassName({
-        doUseDefaultCss,
-        classes
-    });
-
-    const { url, messagesPerField, recaptchaRequired, recaptchaSiteKey, realm } = kcContext;
-
-    realm.registrationEmailAsUsername;
-
-    const { msg, msgStr } = i18n;
-
-    const [isFormSubmittable, setIsFormSubmittable] = useState(false);
-
-    return (
-        <Template
-            {...{ kcContext, i18n, doUseDefaultCss, classes }}
-            displayMessage={messagesPerField.exists("global")}
-            displayRequiredFields={true}
-            headerNode={msg("registerTitle")}
-        >
-            <form id="kc-register-form" className={getClassName("kcFormClass")} action={url.registrationAction} method="post">
-                <UserProfileFormFields
-                    kcContext={kcContext}
-                    onIsFormSubmittableValueChange={setIsFormSubmittable}
-                    i18n={i18n}
-                    getClassName={getClassName}
-                />
-                {recaptchaRequired && (
-                    <div className="form-group">
-                        <div className={getClassName("kcInputWrapperClass")}>
-                            <div className="g-recaptcha" data-size="compact" data-sitekey={recaptchaSiteKey} />
-                        </div>
-                    </div>
-                )}
-                <div className={getClassName("kcFormGroupClass")} style={{ "marginBottom": 30 }}>
-                    <div id="kc-form-options" className={getClassName("kcFormOptionsClass")}>
-                        <div className={getClassName("kcFormOptionsWrapperClass")}>
-                            <span>
-                                <a href={url.loginUrl}>{msg("backToLogin")}</a>
-                            </span>
-                        </div>
-                    </div>
-
-                    <div id="kc-form-buttons" className={getClassName("kcFormButtonsClass")}>
-                        <input
-                            className={clsx(
-                                getClassName("kcButtonClass"),
-                                getClassName("kcButtonPrimaryClass"),
-                                getClassName("kcButtonBlockClass"),
-                                getClassName("kcButtonLargeClass")
-                            )}
-                            type="submit"
-                            value={msgStr("doRegister")}
-                            disabled={!isFormSubmittable}
-                        />
-                    </div>
-                </div>
-            </form>
-        </Template>
-    );
-}