keycloakify 6.0.0-beta.0 → 6.0.0-beta.12

package/src/lib/i18n/index.tsx

@@ -1,233 +1,300 @@
 import "minimal-polyfills/Object.fromEntries";
 //NOTE for later: https://github.com/remarkjs/react-markdown/blob/236182ecf30bd89c1e5a7652acaf8d0bf81e6170/src/renderers.js#L7-L35
+import React, { useEffect, useState, useRef } from "react";
 import ReactMarkdown from "react-markdown";
-import type { kcMessages as t_kcMessages } from "./kcMessages";
+import type baseMessages from "./generated_messages/18.0.1/login/en";
 import { assert } from "tsafe/assert";
-import type { Equals } from "tsafe";
-import { createObjectThatThrowsIfAccessed } from "../tools/createObjectThatThrowsIfAccessed";
-import { Evt } from "evt";
-import { useRerenderOnStateChange } from "evt/hooks";
-import { useMemo } from "react";
-import type { StatefulReadonlyEvt } from "evt";
-
-export type KcMessages = typeof t_kcMessages;
-
-export type KcLanguageTag = keyof KcMessages;
-
-export const kcLanguageTags = [
-    "en",
-    "fr",
-    "ca",
-    "cs",
-    "da",
-    "de",
-    "es",
-    "hu",
-    "it",
-    "ja",
-    "lt",
-    "nl",
-    "no",
-    "pl",
-    "pt-BR",
-    "ru",
-    "sk",
-    "sv",
-    "tr",
-    "zh-CN",
-] as const;
-
-assert<Equals<KcLanguageTag, typeof kcLanguageTags[number]>>();
-
-type KcContextLike = { locale?: { currentLanguageTag: KcLanguageTag } };
-
-export function getCurrentKcLanguageTag(kcContext: KcContextLike) {
-    return kcContext.locale?.currentLanguageTag ?? "en";
-}
-
-export function getTagLabel(params: {
-    kcContext: {
-        locale?: {
-            supported: { languageTag: KcLanguageTag; label: string }[];
-        };
-    };
-    kcLanguageTag: KcLanguageTag;
-}): string {
-    const { kcContext, kcLanguageTag } = params;
+import type { KcContextBase } from "../getKcContext/KcContextBase";
 
-    const { locale } = kcContext;
+export const fallbackLanguageTag = "en";
 
-    assert(locale !== undefined, "Internationalization not enabled");
+export type KcContextLike = {
+    locale?: {
+        currentLanguageTag: string;
+        supported: { languageTag: string; url: string; label: string }[];
+    };
+};
 
-    const targetSupportedLocale = locale.supported.find(({ languageTag }) => languageTag === kcLanguageTag);
+assert<KcContextBase extends KcContextLike ? true : false>();
+
+export type MessageKeyBase = keyof typeof baseMessages | keyof typeof keycloakifyExtraMessages[typeof fallbackLanguageTag];
+
+export type I18n<MessageKey extends string = MessageKeyBase> = {
+    /**
+     * e.g: "en", "fr", "zh-CN"
+     *
+     * The current language
+     */
+    currentLanguageTag: string;
+    /**
+     * To call when the user switch language.
+     * This will cause the page to be reloaded,
+     * on next load currentLanguageTag === newLanguageTag
+     */
+    changeLocale: (newLanguageTag: string) => never;
+    /**
+     * e.g. "en" => "English", "fr" => "Français", ...
+     *
+     * Used to render a select that enable user to switch language.
+     * ex: https://user-images.githubusercontent.com/6702424/186044799-38801eec-4e89-483b-81dd-8e9233e8c0eb.png
+     * */
+    labelBySupportedLanguageTag: Record<string, string>;
+    /**
+     * Examples assuming currentLanguageTag === "en"
+     *
+     * msg("access-denied") === <span>Access denied</span>
+     * msg("impersonateTitleHtml", "Foo") === <span><strong>Foo</strong> Impersonate User</span>
+     */
+    msg: (key: MessageKey, ...args: (string | undefined)[]) => JSX.Element;
+    /**
+     * It's the same thing as msg() but instead of returning a JSX.Element it returns a string.
+     * It can be more convenient to manipulate strings but if there are HTML tags it wont render.
+     * msgStr("impersonateTitleHtml", "Foo") === "<strong>Foo</strong> Impersonate User"
+     */
+    msgStr: (key: MessageKey, ...args: (string | undefined)[]) => string;
+    /**
+     * Examples assuming currentLanguageTag === "en"
+     * advancedMsg("${access-denied} foo bar") === <span>${msgStr("access-denied")} foo bar<span> === <span>Access denied foo bar</span>
+     * advancedMsg("${access-denied}") === advancedMsg("access-denied") === msg("access-denied") === <span>Access denied</span>
+     * advancedMsg("${not-a-message-key}") === advancedMsg(not-a-message-key") === <span>not-a-message-key</span>
+     */
+    advancedMsg: (key: string, ...args: (string | undefined)[]) => JSX.Element;
+    /**
+     * Examples assuming currentLanguageTag === "en"
+     * advancedMsg("${access-denied} foo bar") === msg("access-denied") + " foo bar" === "Access denied foo bar"
+     * advancedMsg("${not-a-message-key}") === advancedMsg(not-a-message-key") === "not-a-message-key"
+     */
+    advancedMsgStr: (key: string, ...args: (string | undefined)[]) => string;
+};
 
-    assert(targetSupportedLocale !== undefined, `${kcLanguageTag} need to be enabled in Keycloak admin`);
+export function __unsafe_useI18n<ExtraMessageKey extends string = never>(params: {
+    kcContext: KcContextLike;
+    extraMessages: { [languageTag: string]: { [key in ExtraMessageKey]: string } };
+    doSkip: boolean;
+}): I18n<MessageKeyBase | ExtraMessageKey> | null {
+    const { kcContext, extraMessages, doSkip } = params;
 
-    return targetSupportedLocale.label;
-}
+    const [i18n, setI18n] = useState<I18n<ExtraMessageKey | MessageKeyBase> | undefined>(undefined);
 
-export function changeLocale(params: {
-    kcContext: {
-        locale?: {
-            supported: { languageTag: KcLanguageTag; url: string }[];
-        };
-    };
-    kcLanguageTag: KcLanguageTag;
-}): never {
-    const { kcContext, kcLanguageTag } = params;
+    const refHasStartedFetching = useRef(false);
 
-    const { locale } = kcContext;
+    useEffect(() => {
+        if (doSkip || refHasStartedFetching.current) {
+            return;
+        }
 
-    assert(locale !== undefined, "Internationalization not enabled");
+        let isMounted = true;
+
+        refHasStartedFetching.current = true;
+
+        (async () => {
+            const { currentLanguageTag = fallbackLanguageTag } = kcContext.locale ?? {};
+
+            const [fallbackMessages, messages] = await Promise.all([
+                import("./generated_messages/18.0.1/login/en"),
+                (() => {
+                    switch (currentLanguageTag) {
+                        case "ca":
+                            return import("./generated_messages/18.0.1/login/ca");
+                        case "cs":
+                            return import("./generated_messages/18.0.1/login/cs");
+                        case "da":
+                            return import("./generated_messages/18.0.1/login/da");
+                        case "de":
+                            return import("./generated_messages/18.0.1/login/de");
+                        case "en":
+                            return import("./generated_messages/18.0.1/login/en");
+                        case "es":
+                            return import("./generated_messages/18.0.1/login/es");
+                        case "fi":
+                            return import("./generated_messages/18.0.1/login/fi");
+                        case "fr":
+                            return import("./generated_messages/18.0.1/login/fr");
+                        case "hu":
+                            return import("./generated_messages/18.0.1/login/hu");
+                        case "it":
+                            return import("./generated_messages/18.0.1/login/it");
+                        case "ja":
+                            return import("./generated_messages/18.0.1/login/ja");
+                        case "lt":
+                            return import("./generated_messages/18.0.1/login/lt");
+                        case "lv":
+                            return import("./generated_messages/18.0.1/login/lv");
+                        case "nl":
+                            return import("./generated_messages/18.0.1/login/nl");
+                        case "no":
+                            return import("./generated_messages/18.0.1/login/no");
+                        case "pl":
+                            return import("./generated_messages/18.0.1/login/pl");
+                        case "pt-BR":
+                            return import("./generated_messages/18.0.1/login/pt-BR");
+                        case "ru":
+                            return import("./generated_messages/18.0.1/login/ru");
+                        case "sk":
+                            return import("./generated_messages/18.0.1/login/sk");
+                        case "sv":
+                            return import("./generated_messages/18.0.1/login/sv");
+                        case "tr":
+                            return import("./generated_messages/18.0.1/login/tr");
+                        case "zh-CN":
+                            return import("./generated_messages/18.0.1/login/zh-CN");
+                        default:
+                            return { "default": {} };
+                    }
+                })()
+            ]).then(modules => modules.map(module => module.default));
+
+            if (!isMounted) {
+                return;
+            }
 
-    const targetSupportedLocale = locale.supported.find(({ languageTag }) => languageTag === kcLanguageTag);
+            setI18n({
+                ...createI18nTranslationFunctions({
+                    "fallbackMessages": {
+                        ...fallbackMessages,
+                        ...(keycloakifyExtraMessages[fallbackLanguageTag] ?? {}),
+                        ...(extraMessages[fallbackLanguageTag] ?? {})
+                    } as any,
+                    "messages": {
+                        ...messages,
+                        ...((keycloakifyExtraMessages as any)[currentLanguageTag] ?? {}),
+                        ...(extraMessages[currentLanguageTag] ?? {})
+                    } as any
+                }),
+                currentLanguageTag,
+                "changeLocale": newLanguageTag => {
+                    const { locale } = kcContext;
+
+                    assert(locale !== undefined, "Internationalization not enabled");
+
+                    const targetSupportedLocale = locale.supported.find(({ languageTag }) => languageTag === newLanguageTag);
+
+                    assert(targetSupportedLocale !== undefined, `${newLanguageTag} need to be enabled in Keycloak admin`);
+
+                    window.location.href = targetSupportedLocale.url;
+
+                    assert(false, "never");
+                },
+                "labelBySupportedLanguageTag": Object.fromEntries(
+                    (kcContext.locale?.supported ?? []).map(({ languageTag, label }) => [languageTag, label])
+                )
+            });
+        })();
+
+        return () => {
+            isMounted = false;
+        };
+    }, []);
 
-    assert(targetSupportedLocale !== undefined, `${kcLanguageTag} need to be enabled in Keycloak admin`);
+    return i18n ?? null;
+}
 
-    window.location.href = targetSupportedLocale.url;
+const useI18n_private = __unsafe_useI18n;
 
-    assert(false, "never");
+export function useI18n<ExtraMessageKey extends string = never>(params: {
+    kcContext: KcContextLike;
+    extraMessages: { [languageTag: string]: { [key in ExtraMessageKey]: string } };
+}): I18n<MessageKeyBase | ExtraMessageKey> | null {
+    return useI18n_private({
+        ...params,
+        "doSkip": false
+    });
 }
 
-export type MessageKey = keyof KcMessages["en"];
+function createI18nTranslationFunctions<MessageKey extends string>(params: {
+    fallbackMessages: Record<MessageKey, string>;
+    messages: Record<MessageKey, string>;
+}): Pick<I18n<MessageKey>, "msg" | "msgStr" | "advancedMsg" | "advancedMsgStr"> {
+    const { fallbackMessages, messages } = params;
 
-function resolveMsg<Key extends string, DoRenderMarkdown extends boolean>(props: {
-    key: Key;
-    args: (string | undefined)[];
-    kcLanguageTag: string;
-    doRenderMarkdown: DoRenderMarkdown;
-    kcMessages: KcMessages;
-}): Key extends MessageKey ? (DoRenderMarkdown extends true ? JSX.Element : string) : undefined {
-    const { key, args, kcLanguageTag, doRenderMarkdown, kcMessages } = props;
+    function resolveMsg(props: { key: string; args: (string | undefined)[]; doRenderMarkdown: boolean }): string | JSX.Element | undefined {
+        const { key, args, doRenderMarkdown } = props;
 
-    let str = kcMessages[kcLanguageTag as any as "en"][key as MessageKey] ?? kcMessages["en"][key as MessageKey];
+        const messageOrUndefined: string | undefined = (messages as any)[key] ?? (fallbackMessages as any)[key];
 
-    if (str === undefined) {
-        return undefined as any;
-    }
+        if (messageOrUndefined === undefined) {
+            return undefined;
+        }
 
-    str = (() => {
-        const startIndex = str
-            .match(/{[0-9]+}/g)
-            ?.map(g => g.match(/{([0-9]+)}/)![1])
-            .map(indexStr => parseInt(indexStr))
-            .sort((a, b) => a - b)[0];
+        const message = messageOrUndefined;
 
-        if (startIndex === undefined) {
-            return str;
-        }
+        const messageWithArgsInjectedIfAny = (() => {
+            const startIndex = message
+                .match(/{[0-9]+}/g)
+                ?.map(g => g.match(/{([0-9]+)}/)![1])
+                .map(indexStr => parseInt(indexStr))
+                .sort((a, b) => a - b)[0];
 
-        args.forEach((arg, i) => {
-            if (arg === undefined) {
-                return;
+            if (startIndex === undefined) {
+                // No {0} in message (no arguments expected)
+                return message;
             }
 
-            str = str.replace(new RegExp(`\\{${i + startIndex}\\}`, "g"), arg);
-        });
+            let messageWithArgsInjected = message;
+
+            args.forEach((arg, i) => {
+                if (arg === undefined) {
+                    return;
+                }
+
+                messageWithArgsInjected = messageWithArgsInjected.replace(new RegExp(`\\{${i + startIndex}\\}`, "g"), arg);
+            });
 
-        return str;
-    })();
+            return messageWithArgsInjected;
+        })();
 
-    return (
-        doRenderMarkdown ? (
+        return doRenderMarkdown ? (
             <ReactMarkdown allowDangerousHtml renderers={key === "termsText" ? undefined : { "paragraph": "span" }}>
-                {str}
+                {messageWithArgsInjectedIfAny}
             </ReactMarkdown>
         ) : (
-            str
-        )
-    ) as any;
-}
-
-function resolveMsgAdvanced<Key extends string, DoRenderMarkdown extends boolean>(props: {
-    key: Key;
-    args: (string | undefined)[];
-    kcLanguageTag: string;
-    doRenderMarkdown: DoRenderMarkdown;
-    kcMessages: KcMessages;
-}): DoRenderMarkdown extends true ? JSX.Element : string {
-    const { key, args, kcLanguageTag, doRenderMarkdown, kcMessages } = props;
-
-    const match = key.match(/^\$\{([^{]+)\}$/);
-
-    const keyUnwrappedFromCurlyBraces = match === null ? key : match[1];
-
-    const out = resolveMsg({
-        "key": keyUnwrappedFromCurlyBraces,
-        args,
-        kcLanguageTag,
-        doRenderMarkdown,
-        kcMessages,
-    });
-
-    return (out !== undefined ? out : doRenderMarkdown ? <span>{keyUnwrappedFromCurlyBraces}</span> : keyUnwrappedFromCurlyBraces) as any;
-}
-
-export type I18n = {
-    msg: (key: MessageKey, ...args: (string | undefined)[]) => JSX.Element;
-    msgStr: (key: MessageKey, ...args: (string | undefined)[]) => string;
-    advancedMsgStr: (key: string, ...args: (string | undefined)[]) => string;
-    advancedMsg: (key: string, ...args: (string | undefined)[]) => JSX.Element;
-    evtKcMessages: StatefulReadonlyEvt<KcMessages | undefined>;
-};
-
-/**
- * advancedMsg("${access-denied}") === advancedMsg("access-denied") === msg("access-denied")
- * advancedMsg("${not-a-message-key}") === advancedMsg(not-a-message-key") === "not-a-message-key"
- */
-export function createUseI18n(props: { kcMessages: KcMessages | (() => Promise<KcMessages>); kcContext: KcContextLike | undefined }) {
-    const { kcContext, kcMessages: kcMessagesOrFetchKcMessages } = props;
-
-    if (kcContext === undefined) {
-        return createObjectThatThrowsIfAccessed({ "debugMessage": "Can't use Keycloakify i18n outside of keycloak" });
+            messageWithArgsInjectedIfAny
+        );
     }
 
-    const { evtKcMessages } = (() => {
-        const evtKcMessages = Evt.create<KcMessages | undefined>(undefined);
+    function resolveMsgAdvanced(props: { key: string; args: (string | undefined)[]; doRenderMarkdown: boolean }): JSX.Element | string {
+        const { key, args, doRenderMarkdown } = props;
 
-        if (typeof kcMessagesOrFetchKcMessages === "function") {
-            kcMessagesOrFetchKcMessages().then(kcMessages => (evtKcMessages.state = kcMessages));
-        } else {
-            evtKcMessages.state = kcMessagesOrFetchKcMessages;
-        }
+        const match = key.match(/^\$\{([^{]+)\}$/);
 
-        return { evtKcMessages };
-    })();
-    Evt.factorize(
-        typeof kcMessagesOrFetchKcMessages === "function"
-            ? Evt.from(kcMessagesOrFetchKcMessages()).toStateful()
-            : Evt.create(kcMessagesOrFetchKcMessages),
-    );
-
-    const kcLanguageTag = getCurrentKcLanguageTag(kcContext);
-
-    function useI18n() {
-        useRerenderOnStateChange(evtKcMessages);
-
-        const i18n = useMemo((): I18n => {
-            const kcMessages = evtKcMessages.state;
-
-            if (kcMessages === undefined) {
-                return {
-                    "msgStr": () => "",
-                    "msg": () => <></>,
-                    "advancedMsg": () => <></>,
-                    "advancedMsgStr": () => "",
-                    evtKcMessages,
-                };
-            }
+        const keyUnwrappedFromCurlyBraces = match === null ? key : match[1];
 
-            return {
-                "msgStr": (key, ...args) => resolveMsg({ key, args, kcLanguageTag, "doRenderMarkdown": false, kcMessages }),
-                "msg": (key, ...args): JSX.Element => resolveMsg({ key, args, kcLanguageTag, "doRenderMarkdown": true, kcMessages }),
-                "advancedMsg": (key, ...args) => resolveMsgAdvanced({ key, args, kcLanguageTag, "doRenderMarkdown": true, kcMessages }),
-                "advancedMsgStr": (key, ...args) => resolveMsgAdvanced({ key, args, kcLanguageTag, "doRenderMarkdown": false, kcMessages }),
-                evtKcMessages,
-            };
-        }, [evtKcMessages.state]);
+        const out = resolveMsg({
+            "key": keyUnwrappedFromCurlyBraces,
+            args,
+            doRenderMarkdown
+        });
 
-        return i18n;
+        return (out !== undefined ? out : doRenderMarkdown ? <span>{keyUnwrappedFromCurlyBraces}</span> : keyUnwrappedFromCurlyBraces) as any;
     }
 
-    return { useI18n };
+    return {
+        "msgStr": (key, ...args) => resolveMsg({ key, args, "doRenderMarkdown": false }) as string,
+        "msg": (key, ...args) => resolveMsg({ key, args, "doRenderMarkdown": true }) as JSX.Element,
+        "advancedMsg": (key, ...args) => resolveMsgAdvanced({ key, args, "doRenderMarkdown": true }) as JSX.Element,
+        "advancedMsgStr": (key, ...args) => resolveMsgAdvanced({ key, args, "doRenderMarkdown": false }) as string
+    };
 }
+
+const keycloakifyExtraMessages = {
+    "en": {
+        "shouldBeEqual": "{0} should be equal to {1}",
+        "shouldBeDifferent": "{0} should be different to {1}",
+        "shouldMatchPattern": "Pattern should match: `/{0}/`",
+        "mustBeAnInteger": "Must be an integer",
+        "notAValidOption": "Not a valid option"
+    },
+    "fr": {
+        /* spell-checker: disable */
+        "shouldBeEqual": "{0} doit être égal à {1}",
+        "shouldBeDifferent": "{0} doit être différent de {1}",
+        "shouldMatchPattern": "Dois respecter le schéma: `/{0}/`",
+        "mustBeAnInteger": "Doit être un nombre entier",
+        "notAValidOption": "N'est pas une option valide",
+
+        "logoutConfirmTitle": "Déconnexion",
+        "logoutConfirmHeader": "Êtes-vous sûr(e) de vouloir vous déconnecter ?",
+        "doLogout": "Se déconnecter"
+        /* spell-checker: enable */
+    }
+};

package/src/lib/index.ts

@@ -4,9 +4,10 @@ export * from "./i18n";
 
 export { useDownloadTerms } from "./components/Terms";
 
-export * from "./components/KcApp";
 export * from "./components/KcProps";
 export * from "./keycloakJsAdapter";
 export * from "./useFormValidationSlice";
 
-export * from "./tools/assert";
+import KcApp from "./components/KcApp";
+
+export default KcApp;

package/src/lib/keycloakJsAdapter.ts

@@ -44,35 +44,61 @@ export declare namespace keycloak_js {
 export function createKeycloakAdapter(params: {
     keycloakInstance: keycloak_js.KeycloakInstance;
     transformUrlBeforeRedirect(url: string): string;
+    getRedirectMethod?: () => "overwrite location.href" | "location.replace";
 }): keycloak_js.KeycloakAdapter {
-    const { keycloakInstance, transformUrlBeforeRedirect } = params;
+    const { keycloakInstance, transformUrlBeforeRedirect, getRedirectMethod = () => "overwrite location.href" } = params;
 
     const neverResolvingPromise: keycloak_js.KeycloakPromise<void, void> = Object.defineProperties(new Promise(() => {}), {
         "success": { "value": () => {} },
-        "error": { "value": () => {} },
+        "error": { "value": () => {} }
     }) as any;
 
     return {
         "login": options => {
-            window.location.href = transformUrlBeforeRedirect(keycloakInstance.createLoginUrl(options));
-            return neverResolvingPromise;
-        },
-        "logout": options => {
-            window.location.replace(transformUrlBeforeRedirect(keycloakInstance.createLogoutUrl(options)));
+            const newHref = transformUrlBeforeRedirect(keycloakInstance.createLoginUrl(options));
+            switch (getRedirectMethod()) {
+                case "location.replace":
+                    window.location.replace(newHref);
+                    break;
+                case "overwrite location.href":
+                    window.location.href = newHref;
+                    break;
+            }
             return neverResolvingPromise;
         },
         "register": options => {
-            window.location.href = transformUrlBeforeRedirect(keycloakInstance.createRegisterUrl(options));
+            const newHref = transformUrlBeforeRedirect(keycloakInstance.createRegisterUrl(options));
+            switch (getRedirectMethod()) {
+                case "location.replace":
+                    window.location.replace(newHref);
+                    break;
+                case "overwrite location.href":
+                    window.location.href = newHref;
+                    break;
+            }
 
             return neverResolvingPromise;
         },
+        "logout": options => {
+            window.location.replace(transformUrlBeforeRedirect(keycloakInstance.createLogoutUrl(options)));
+            return neverResolvingPromise;
+        },
         "accountManagement": () => {
-            var accountUrl = transformUrlBeforeRedirect(keycloakInstance.createAccountUrl());
-            if (typeof accountUrl !== "undefined") {
-                window.location.href = accountUrl;
-            } else {
+            const accountUrl = transformUrlBeforeRedirect(keycloakInstance.createAccountUrl());
+
+            if (accountUrl === "undefined") {
                 throw new Error("Not supported by the OIDC server");
             }
+
+            switch (getRedirectMethod()) {
+                case "location.replace":
+                    window.location.replace(accountUrl);
+                    break;
+                case "overwrite location.href":
+                    window.location.href = accountUrl;
+                    break;
+            }
+
             return neverResolvingPromise;
         },
         "redirectUri": options => {
@@ -83,6 +109,6 @@ export function createKeycloakAdapter(params: {
             } else {
                 return window.location.href;
             }
-        },
+        }
     };
 }

package/src/lib/tools/AndByDiscriminatingKey.ts

@@ -1,7 +1,7 @@
 export type AndByDiscriminatingKey<
     DiscriminatingKey extends string,
     U1 extends Record<DiscriminatingKey, string>,
-    U2 extends Record<DiscriminatingKey, string>,
+    U2 extends Record<DiscriminatingKey, string>
 > = AndByDiscriminatingKey.Tf1<DiscriminatingKey, U1, U1, U2>;
 
 export declare namespace AndByDiscriminatingKey {
@@ -9,13 +9,13 @@ export declare namespace AndByDiscriminatingKey {
         DiscriminatingKey extends string,
         U1,
         U1Again extends Record<DiscriminatingKey, string>,
-        U2 extends Record<DiscriminatingKey, string>,
+        U2 extends Record<DiscriminatingKey, string>
     > = U1 extends Pick<U2, DiscriminatingKey> ? Tf2<DiscriminatingKey, U1, U2, U1Again> : U1;
 
     export type Tf2<
         DiscriminatingKey extends string,
         SingletonU1 extends Record<DiscriminatingKey, string>,
         U2,
-        U1 extends Record<DiscriminatingKey, string>,
+        U1 extends Record<DiscriminatingKey, string>
     > = U2 extends Pick<SingletonU1, DiscriminatingKey> ? U2 & SingletonU1 : U2 extends Pick<U1, DiscriminatingKey> ? never : U2;
 }

package/src/lib/tools/deepAssign.ts

@@ -16,7 +16,7 @@ export function deepAssign(params: { target: Record<string, unknown>; source: Re
                 "enumerable": true,
                 "writable": true,
                 "configurable": true,
-                "value": dereferencedSource,
+                "value": dereferencedSource
             });
 
             return;
@@ -38,7 +38,7 @@ export function deepAssign(params: { target: Record<string, unknown>; source: Re
 
         deepAssign({
             "target": dereferencedTarget,
-            "source": dereferencedSource,
+            "source": dereferencedSource
         });
     });
 }

package/src/lib/tools/headInsert.ts

@@ -11,7 +11,7 @@ export function headInsert(
         | {
               type: "javascript";
               src: string;
-          },
+          }
 ) {
     const htmlElement = document.createElement(
         (() => {
@@ -21,7 +21,7 @@ export function headInsert(
                 case "javascript":
                     return "script";
             }
-        })(),
+        })()
     );
 
     const dLoaded = new Deferred<void>();
@@ -37,15 +37,15 @@ export function headInsert(
                         "href": params.href,
                         "type": "text/css",
                         "rel": "stylesheet",
-                        "media": "screen,print",
+                        "media": "screen,print"
                     };
                 case "javascript":
                     return {
                         "src": params.src,
-                        "type": "text/javascript",
+                        "type": "text/javascript"
                     };
             }
-        })(),
+        })()
     );
 
     document.getElementsByTagName("head")[0][