keycloakify 10.0.0-rc.3 → 10.0.0-rc.30

package/src/login/pages/WebauthnRegister.tsx

@@ -1,14 +1,12 @@
 import { useEffect } from "react";
+import { assert } from "tsafe/assert";
 import { clsx } from "keycloakify/tools/clsx";
-import type { PageProps } from "keycloakify/login/pages/PageProps";
 import { useGetClassName } from "keycloakify/login/lib/useGetClassName";
-import { assert } from "tsafe/assert";
-import { createUseInsertScriptTags } from "keycloakify/tools/useInsertScriptTags";
-import type { KcContext } from "../kcContext";
+import { useInsertScriptTags } from "keycloakify/tools/useInsertScriptTags";
+import type { PageProps } from "keycloakify/login/pages/PageProps";
+import type { KcContext } from "../KcContext";
 import type { I18n } from "../i18n";
 
-const { useInsertScriptTags } = createUseInsertScriptTags();
-
 export default function WebauthnRegister(props: PageProps<Extract<KcContext, { pageId: "webauthn-register.ftl" }>, I18n>) {
     const { kcContext, i18n, doUseDefaultCss, Template, classes } = props;
 
@@ -35,18 +33,19 @@ export default function WebauthnRegister(props: PageProps<Extract<KcContext, { p
     const { msg, msgStr } = i18n;
 
     const { insertScriptTags } = useInsertScriptTags({
-        "scriptTags": [
+        componentOrHookName: "WebauthnRegister",
+        scriptTags: [
             {
-                "type": "text/javascript",
-                "src": `${url.resourcesCommonPath}/node_modules/jquery/dist/jquery.min.js`
+                type: "text/javascript",
+                src: `${url.resourcesCommonPath}/node_modules/jquery/dist/jquery.min.js`
             },
             {
-                "type": "text/javascript",
-                "src": `${url.resourcesPath}/js/base64url.js`
+                type: "text/javascript",
+                src: `${url.resourcesPath}/js/base64url.js`
             },
             {
-                "type": "text/javascript",
-                "textContent": `
+                type: "text/javascript",
+                textContent: `
                 function registerSecurityKey() {
 
                     // Check if WebAuthn is supported by this browser

package/src/tools/Array.prototype.every.ts

@@ -17,7 +17,10 @@ if (!Array.prototype.every) {
         var len = O.length >>> 0;
 
         // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
-        if (typeof callbackfn !== "function" && Object.prototype.toString.call(callbackfn) !== "[object Function]") {
+        if (
+            typeof callbackfn !== "function" &&
+            Object.prototype.toString.call(callbackfn) !== "[object Function]"
+        ) {
             throw new TypeError();
         }
 

package/src/tools/ExtractAfterStartingWith.ts

@@ -0,0 +1,4 @@
+export type ExtractAfterStartingWith<
+    Prefix extends string,
+    StrEnum
+> = StrEnum extends `${Prefix}${infer U}` ? U : never;

package/src/tools/LazyOrNot.ts

@@ -1,3 +1,5 @@
 import type { LazyExoticComponent, ComponentType } from "react";
 
-export type LazyOrNot<Component extends ComponentType<any>> = LazyExoticComponent<Component> | Component;
+export type LazyOrNot<Component extends ComponentType<any>> =
+    | LazyExoticComponent<Component>
+    | Component;

package/src/tools/Object.fromEntries.ts

@@ -0,0 +1,23 @@
+if (!(Object as any).fromEntries) {
+    Object.defineProperty(Object, "fromEntries", {
+        value: function (entries: any) {
+            if (!entries || !entries[Symbol.iterator]) {
+                throw new Error(
+                    "Object.fromEntries() requires a single iterable argument"
+                );
+            }
+
+            const o: any = {};
+
+            Object.keys(entries).forEach(key => {
+                const [k, v] = entries[key];
+
+                o[k] = v;
+            });
+
+            return o;
+        }
+    });
+}
+
+export {};

package/src/tools/StatefulObservable/README.md

@@ -0,0 +1,16 @@
+`StatefulObservable` is a construct that allow to avoid having to depend on [EVT](https://evt.land).
+
+A `StatefulObservable` can be converted to an evt with:
+
+```ts
+import { statefulObservableToStatefulEvt } from "powerhooks/tools/StatefulObservable/statefulObservableToStatefulEvt";
+
+const evtXyz = statefulObservableToStatefulEvt({
+    statefulObservable: $xyz
+    //Optionally you can pass a Ctx
+});
+```
+
+WARNING: Unlike `StatefulEvt`, `StatefulObservable` do not post when we first attach.
+If the current value was not yet evaluated `next()` is called on the initial value returned by the function that
+returns it.

package/src/tools/StatefulObservable/StatefulObservable.ts

@@ -0,0 +1,58 @@
+import { assert } from "tsafe/assert";
+import { is } from "tsafe/is";
+
+export type StatefulObservable<T> = {
+    current: T;
+    subscribe: (next: (data: T) => void) => Subscription;
+};
+
+export type Subscription = {
+    unsubscribe(): void;
+};
+
+export function createStatefulObservable<T>(
+    getInitialValue: () => T
+): StatefulObservable<T> {
+    const nextFunctions: ((data: T) => void)[] = [];
+
+    const { get, set } = (() => {
+        let wrappedState: [T] | undefined = undefined;
+
+        function set(data: T) {
+            wrappedState = [data];
+
+            nextFunctions.forEach(next => next(data));
+        }
+
+        return {
+            get: () => {
+                if (wrappedState === undefined) {
+                    set(getInitialValue());
+                    assert(!is<undefined>(wrappedState));
+                }
+                return wrappedState[0];
+            },
+            set
+        };
+    })();
+
+    return Object.defineProperty(
+        {
+            current: null as any as T,
+            subscribe: (next: (data: T) => void) => {
+                nextFunctions.push(next);
+
+                return {
+                    unsubscribe: () =>
+                        nextFunctions.splice(nextFunctions.indexOf(next), 1)
+                };
+            }
+        },
+        "current",
+        {
+            enumerable: true,
+            get,
+            set
+        }
+    );
+}

package/src/tools/StatefulObservable/hooks/index.ts

@@ -0,0 +1,2 @@
+export * from "./useObservable";
+export * from "./useRerenderOnChange";

package/src/tools/StatefulObservable/hooks/useObservable.ts

@@ -0,0 +1,25 @@
+import { useEffect } from "react";
+import type { Subscription } from "../StatefulObservable";
+
+/**
+ * Equivalent of https://docs.evt.land/api/react-hooks
+ */
+export function useObservable(
+    effect: (params: {
+        registerSubscription: (subscription: Subscription) => void;
+    }) => void,
+    deps: React.DependencyList
+): void {
+    useEffect(() => {
+        const subscriptions: Subscription[] = [];
+
+        effect({
+            registerSubscription: subscription => subscriptions.push(subscription)
+        });
+
+        return () => {
+            subscriptions.forEach(subscription => subscription.unsubscribe());
+            subscriptions.length = 0;
+        };
+    }, deps);
+}

package/src/tools/StatefulObservable/hooks/useRerenderOnChange.ts

@@ -0,0 +1,19 @@
+import { useObservable } from "./useObservable";
+import { useState } from "react";
+import type { StatefulObservable } from "../StatefulObservable";
+
+/**
+ * Equivalent of https://docs.evt.land/api/react-hooks
+ * */
+export function useRerenderOnChange(obs: StatefulObservable<unknown>): void {
+    //NOTE: We use function in case the state is a function
+    const [, setCurrent] = useState(() => obs.current);
+
+    useObservable(
+        ({ registerSubscription }) => {
+            const subscription = obs.subscribe(current => setCurrent(() => current));
+            registerSubscription(subscription);
+        },
+        [obs]
+    );
+}

package/src/tools/StatefulObservable/index.ts

@@ -0,0 +1,2 @@
+export * from "./StatefulObservable";
+export * from "./hooks";

package/src/tools/ValueOf.ts

@@ -0,0 +1,2 @@
+/** Pendant of `keyof T` */
+export type ValueOf<T> = T[keyof T];

package/src/tools/clsx.ts

@@ -1,7 +1,13 @@
 import { assert } from "tsafe/assert";
 import { typeGuard } from "tsafe/typeGuard";
 
-export type CxArg = undefined | null | string | boolean | Partial<Record<string, boolean | null | undefined>> | readonly CxArg[];
+export type CxArg =
+    | undefined
+    | null
+    | string
+    | boolean
+    | Partial<Record<string, boolean | null | undefined>>
+    | readonly CxArg[];
 
 export const clsx = (...args: CxArg[]): string => {
     const len = args.length;

package/src/tools/deepAssign.ts

@@ -1,44 +1,82 @@
 import { assert } from "tsafe/assert";
 import { is } from "tsafe/is";
-import { deepClone } from "./deepClone";
+import { structuredCloneButFunctions } from "./structuredCloneButFunctions";
 
-//Warning: Be mindful that because of array this is not idempotent.
-export function deepAssign(params: { target: Record<string, unknown>; source: Record<string, unknown> }) {
-    const { target } = params;
-
-    const source = deepClone(params.source);
+/** NOTE: Array a copied over, not merged. */
+export function deepAssign(params: {
+    target: Record<string, unknown>;
+    source: Record<string, unknown>;
+}): void {
+    const { target, source } = params;
 
     Object.keys(source).forEach(key => {
         var dereferencedSource = source[key];
 
-        if (target[key] === undefined || dereferencedSource instanceof Function || !(dereferencedSource instanceof Object)) {
-            Object.defineProperty(target, key, {
-                "enumerable": true,
-                "writable": true,
-                "configurable": true,
-                "value": dereferencedSource
+        if (dereferencedSource === undefined) {
+            delete target[key];
+            return;
+        }
+
+        if (dereferencedSource instanceof Date) {
+            assign({
+                target,
+                key,
+                value: new Date(dereferencedSource.getTime())
             });
 
             return;
         }
 
-        const dereferencedTarget = target[key];
-
         if (dereferencedSource instanceof Array) {
-            assert(is<unknown[]>(dereferencedTarget));
-            assert(is<unknown[]>(dereferencedSource));
+            assign({
+                target,
+                key,
+                value: structuredCloneButFunctions(dereferencedSource)
+            });
 
-            dereferencedSource.forEach(entry => dereferencedTarget.push(entry));
+            return;
+        }
+
+        if (
+            dereferencedSource instanceof Function ||
+            !(dereferencedSource instanceof Object)
+        ) {
+            assign({
+                target,
+                key,
+                value: dereferencedSource
+            });
 
             return;
         }
 
+        if (!(target[key] instanceof Object)) {
+            target[key] = {};
+        }
+
+        const dereferencedTarget = target[key];
+
         assert(is<Record<string, unknown>>(dereferencedTarget));
         assert(is<Record<string, unknown>>(dereferencedSource));
 
         deepAssign({
-            "target": dereferencedTarget,
-            "source": dereferencedSource
+            target: dereferencedTarget,
+            source: dereferencedSource
         });
     });
 }
+
+function assign(params: {
+    target: Record<string, unknown>;
+    key: string;
+    value: unknown;
+}): void {
+    const { target, key, value } = params;
+
+    Object.defineProperty(target, key, {
+        enumerable: true,
+        writable: true,
+        configurable: true,
+        value
+    });
+}

package/src/tools/formatNumber.ts

@@ -11,7 +11,10 @@ export const formatNumber = (input: string, format: string): string => {
     }
 
     // calculate the maximum size of the given pattern based on the sum of the expected digits
-    const maxSize = digitPattern.reduce((total, p) => total + parseInt(p.replace("{", "").replace("}", "")), 0);
+    const maxSize = digitPattern.reduce(
+        (total, p) => total + parseInt(p.replace("{", "").replace("}", "")),
+        0
+    );
 
     // keep only digits
     let rawValue = input.replace(/\D+/g, "");

package/src/tools/structuredCloneButFunctions.ts

@@ -0,0 +1,24 @@
+import "./Object.fromEntries";
+
+/**
+ * Functionally equivalent to structuredClone but
+ * functions are not cloned but kept as is.
+ * (as opposed to structuredClone that chokes if it encounters a function)
+ */
+export function structuredCloneButFunctions<T>(o: T): T {
+    if (!(o instanceof Object)) {
+        return o;
+    }
+
+    if (typeof o === "function") {
+        return o;
+    }
+
+    if (o instanceof Array) {
+        return o.map(structuredCloneButFunctions) as any;
+    }
+
+    return Object.fromEntries(
+        Object.entries(o).map(([key, value]) => [key, structuredCloneButFunctions(value)])
+    ) as any;
+}

package/src/tools/useConstCallback.ts

@@ -2,7 +2,9 @@ import { useRef, useState } from "react";
 import { Parameters } from "tsafe/Parameters";
 
 /** https://stackoverflow.com/questions/65890278/why-cant-usecallback-always-return-the-same-ref */
-export function useConstCallback<T extends ((...args: any[]) => unknown) | undefined | null>(callback: NonNullable<T>): T {
+export function useConstCallback<
+    T extends ((...args: any[]) => unknown) | undefined | null
+>(callback: NonNullable<T>): T {
     const callbackRef = useRef<typeof callback>(null as any);
 
     callbackRef.current = callback;

package/src/tools/useInsertLinkTags.ts

@@ -1,82 +1,86 @@
-import { useReducer, useEffect } from "react";
-
-export function createUseInsertLinkTags() {
-    let linkTagsContext:
-        | {
-              styleSheetHrefs: string[];
-              prAreAllStyleSheetsLoaded: Promise<void>;
-              remove: () => void;
-          }
-        | undefined = undefined;
-
-    /** NOTE: The hrefs can't changes. There should be only one one call on this. */
-    function useInsertLinkTags(params: { hrefs: string[] }) {
-        const { hrefs } = params;
-
-        const [areAllStyleSheetsLoaded, setAllStyleSheetLoaded] = useReducer(() => true, hrefs.length === 0);
-
-        useEffect(() => {
-            let isActive = true;
-
-            mount_link_tags: {
-                if (linkTagsContext !== undefined) {
-                    if (JSON.stringify(linkTagsContext.styleSheetHrefs) === JSON.stringify(hrefs)) {
-                        break mount_link_tags;
-                    }
-
-                    linkTagsContext.remove();
-
-                    linkTagsContext = undefined;
+import { useEffect, useReducer } from "react";
+import { useConst } from "keycloakify/tools/useConst";
+import { id } from "tsafe/id";
+import { useOnFistMount } from "keycloakify/tools/useOnFirstMount";
+
+const alreadyMountedComponentOrHookNames = new Set<string>();
+
+/**
+ * NOTE: The component that use this hook can only be mounded once!
+ * And can't rerender with different hrefs.
+ * If it's mounted again the page will be reloaded.
+ * This simulates the behavior of a server rendered page that imports css stylesheet in the head.
+ */
+export function useInsertLinkTags(params: {
+    componentOrHookName: string;
+    hrefs: string[];
+}) {
+    const { hrefs, componentOrHookName } = params;
+
+    useOnFistMount(() => {
+        const isAlreadyMounted =
+            alreadyMountedComponentOrHookNames.has(componentOrHookName);
+
+        if (isAlreadyMounted) {
+            window.location.reload();
+            return;
+        }
+
+        alreadyMountedComponentOrHookNames.add(componentOrHookName);
+    });
+
+    const [areAllStyleSheetsLoaded, setAllStyleSheetsLoaded] = useReducer(
+        () => true,
+        false
+    );
+
+    const refPrAllStyleSheetLoaded = useConst(() => ({
+        current: id<Promise<void> | undefined>(undefined)
+    }));
+
+    useEffect(() => {
+        let isActive = true;
+
+        (refPrAllStyleSheetLoaded.current ??= (async () => {
+            let lastMountedHtmlElement: HTMLLinkElement | undefined = undefined;
+
+            const prs: Promise<void>[] = [];
+
+            for (const href of hrefs) {
+                const htmlElement = document.createElement("link");
+
+                prs.push(
+                    new Promise<void>(resolve =>
+                        htmlElement.addEventListener("load", () => resolve())
+                    )
+                );
+
+                htmlElement.rel = "stylesheet";
+
+                htmlElement.href = href;
+
+                if (lastMountedHtmlElement !== undefined) {
+                    lastMountedHtmlElement.insertAdjacentElement("afterend", htmlElement);
+                } else {
+                    document.head.prepend(htmlElement);
                 }
 
-                let lastMountedHtmlElement: HTMLLinkElement | undefined = undefined;
-
-                const prs: Promise<void>[] = [];
-                const removeFns: (() => void)[] = [];
-
-                for (const href of hrefs) {
-                    const htmlElement = document.createElement("link");
-
-                    prs.push(new Promise<void>(resolve => htmlElement.addEventListener("load", () => resolve())));
-
-                    htmlElement.rel = "stylesheet";
-
-                    htmlElement.href = href;
-
-                    if (lastMountedHtmlElement !== undefined) {
-                        lastMountedHtmlElement.insertAdjacentElement("afterend", htmlElement);
-                    } else {
-                        document.head.prepend(htmlElement);
-                    }
-
-                    removeFns.push(() => {
-                        htmlElement.remove();
-                    });
-
-                    lastMountedHtmlElement = htmlElement;
-                }
-
-                linkTagsContext = {
-                    "styleSheetHrefs": hrefs,
-                    "prAreAllStyleSheetsLoaded": Promise.all(prs).then(() => undefined),
-                    "remove": () => removeFns.forEach(fn => fn())
-                };
+                lastMountedHtmlElement = htmlElement;
             }
 
-            linkTagsContext.prAreAllStyleSheetsLoaded.then(() => {
-                if (!isActive) {
-                    return;
-                }
-                setAllStyleSheetLoaded();
-            });
+            await Promise.all(prs);
+        })()).then(() => {
+            if (!isActive) {
+                return;
+            }
 
-            return () => {
-                isActive = false;
-            };
-        }, []);
+            setAllStyleSheetsLoaded();
+        });
 
-        return { areAllStyleSheetsLoaded };
-    }
+        return () => {
+            isActive = false;
+        };
+    }, []);
 
-    return { useInsertLinkTags };
+    return { areAllStyleSheetsLoaded };
 }