@multiplatform.one/keycloak 0.7.1 → 0.7.3

package/lib/chunk-DKRUDENY.mjs

@@ -0,0 +1,265 @@
+import {
+  AfterAuth
+} from "./chunk-SK4YK6KE.mjs";
+import {
+  useAuthConfig
+} from "./chunk-Y4XMF3R6.mjs";
+import {
+  useAuthState
+} from "./chunk-AD6VPMID.mjs";
+import {
+  validToken
+} from "./chunk-7MTPH6XK.mjs";
+
+// src/provider/keycloakProvider.tsx
+import Keycloak from "@bitspur/keycloak-js";
+import React, { useMemo, useEffect, useState, useCallback } from "react";
+import { MultiPlatform } from "multiplatform.one";
+import { ReactKeycloakProvider } from "@bitspur/react-keycloak-web";
+import { SSRKeycloakProvider, SSRCookies } from "@bitspur/react-keycloak-ssr";
+import { useRouter } from "next/router";
+var logger = console;
+function KeycloakProvider({
+  children,
+  cookies,
+  keycloakConfig,
+  keycloakInitOptions,
+  loadingComponent,
+  onEvent,
+  onTokens
+}) {
+  const { debug, ensureFreshness, persist, messageHandlerKeys, ssr } = useAuthConfig();
+  const authState = useAuthState();
+  const LoadingComponent = loadingComponent || (() => /* @__PURE__ */ React.createElement(React.Fragment, null, debug ? "authenticating" : null));
+  const { query } = MultiPlatform.isNext ? useRouter() : { query: {} };
+  const [refreshToken, setRefreshToken] = useState(
+    validToken(
+      ensureFreshness && ("refreshToken" in query && (query.refreshToken?.toString() || true) || persist && authState.refreshToken) || false
+    )
+  );
+  const [idToken, setIdToken] = useState(
+    validToken(
+      "idToken" in query && (query.idToken?.toString() || true) || persist && authState.idToken || false,
+      refreshToken
+    )
+  );
+  const [token, setToken] = useState(
+    validToken(
+      "token" in query && (query.token?.toString() || true) || persist && authState.token || false,
+      refreshToken
+    )
+  );
+  useEffect(() => {
+    if (token !== true && refreshToken !== true && idToken !== true)
+      return;
+    if (debug)
+      logger.debug("post message", JSON.stringify({ type: "LOADED" }));
+    (messageHandlerKeys || []).forEach((key) => {
+      window?.webkit?.messageHandlers?.[key]?.postMessage(JSON.stringify({ type: "LOADED" }));
+    });
+    window?.ReactNativeWebView?.postMessage(JSON.stringify({ type: "LOADED" }));
+    window?.parent?.postMessage(JSON.stringify({ type: "LOADED" }));
+  }, []);
+  useEffect(() => {
+    if (refreshToken !== true)
+      return;
+    const messageCallback = (e) => {
+      let data = e?.data || null;
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch (err) {
+        }
+      }
+      if (debug)
+        logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      if (!message.type)
+        return;
+      if (message.type.toUpperCase() === "REFRESH_TOKEN" && message.payload) {
+        if (debug)
+          logger.debug("setting refresh token", message.payload);
+        setRefreshToken(validToken(message.payload));
+        window.removeEventListener("message", messageCallback);
+      }
+    };
+    if (debug) {
+      logger.debug(
+        "listening for message",
+        JSON.stringify({
+          type: "REFRESH_TOKEN",
+          payload: "<some_refresh_token>"
+        })
+      );
+    }
+    window.addEventListener("message", messageCallback);
+    return () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []);
+  useEffect(() => {
+    if (token !== true)
+      return;
+    const messageCallback = (e) => {
+      let data = e?.data || null;
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch (err) {
+        }
+      }
+      if (debug)
+        logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      if (!message.type)
+        return;
+      if (message.type.toUpperCase() === "TOKEN" && message.payload) {
+        if (debug)
+          logger.debug("setting token", message.payload);
+        setToken(validToken(message.payload, refreshToken));
+        window.removeEventListener("message", messageCallback);
+      }
+    };
+    if (debug) {
+      logger.debug(
+        "listening for message",
+        JSON.stringify({
+          type: "TOKEN",
+          payload: "<some_token>"
+        })
+      );
+    }
+    window.addEventListener("message", messageCallback);
+    return () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []);
+  useEffect(() => {
+    if (idToken !== true)
+      return;
+    const messageCallback = (e) => {
+      let data = e?.data || null;
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch (err) {
+        }
+      }
+      if (debug)
+        logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      if (!message.type)
+        return;
+      if (message.type.toUpperCase() === "ID_TOKEN" && message.payload) {
+        if (debug)
+          logger.debug("setting id token", message.payload);
+        setIdToken(validToken(message.payload, refreshToken));
+        window.removeEventListener("message", messageCallback);
+      }
+    };
+    if (debug) {
+      logger.debug(
+        "listening for message",
+        JSON.stringify({
+          type: "ID_TOKEN",
+          payload: "<some_id_token>"
+        })
+      );
+    }
+    window.addEventListener("message", messageCallback);
+    return () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []);
+  const handleEvent = useCallback((eventType, error) => {
+    if (error) {
+      if (typeof error === "string")
+        throw new Error(error);
+      const err = new Error(error.error);
+      err.errorDescription = error.error_description;
+      throw err;
+    }
+    if (onEvent)
+      onEvent(eventType, error);
+  }, []);
+  const keycloak = useMemo(
+    () => typeof window !== "undefined" && new Keycloak({
+      url: keycloakConfig.url,
+      realm: keycloakConfig.realm,
+      clientId: keycloakConfig.clientId
+    }),
+    [keycloakInitOptions, token, refreshToken, idToken]
+  );
+  const initOptions = useMemo(() => {
+    const initOptions2 = {
+      ...defaultKeycloakInitOptions,
+      ...keycloakInitOptions
+    };
+    if (debug)
+      initOptions2.enableLogging = true;
+    if (token && typeof token === "string") {
+      initOptions2.token = token;
+      initOptions2.timeSkew = 0;
+      if (idToken && typeof idToken === "string")
+        initOptions2.idToken = idToken;
+      if (refreshToken && typeof refreshToken === "string")
+        initOptions2.refreshToken = refreshToken;
+    }
+    if (typeof window !== "undefined" && window.self !== window.top || token && !refreshToken) {
+      initOptions2.checkLoginIframe = false;
+      initOptions2.flow = "implicit";
+      initOptions2.onLoad = void 0;
+    }
+    return initOptions2;
+  }, [keycloakInitOptions, token, refreshToken, idToken]);
+  if (token === true || idToken === true || refreshToken === true)
+    return /* @__PURE__ */ React.createElement(LoadingComponent, null);
+  if (cookies && ssr) {
+    return (
+      // @ts-ignore
+      /* @__PURE__ */ React.createElement(
+        SSRKeycloakProvider,
+        {
+          LoadingComponent: /* @__PURE__ */ React.createElement(LoadingComponent, null),
+          autoRefreshToken: initOptions.checkLoginIframe,
+          initOptions,
+          onEvent: handleEvent,
+          onTokens,
+          persistor: SSRCookies(cookies),
+          keycloakConfig: {
+            clientId: keycloakConfig.clientId,
+            realm: keycloakConfig.realm,
+            url: keycloakConfig.url
+          }
+        },
+        /* @__PURE__ */ React.createElement(AfterAuth, null, children)
+      )
+    );
+  }
+  if (!keycloak)
+    return /* @__PURE__ */ React.createElement(LoadingComponent, null);
+  return /* @__PURE__ */ React.createElement(
+    ReactKeycloakProvider,
+    {
+      LoadingComponent: /* @__PURE__ */ React.createElement(LoadingComponent, null),
+      authClient: keycloak,
+      autoRefreshToken: initOptions.checkLoginIframe,
+      initOptions,
+      onEvent: handleEvent,
+      onTokens
+    },
+    /* @__PURE__ */ React.createElement(AfterAuth, null, children)
+  );
+}
+var defaultKeycloakInitOptions = {
+  checkLoginIframe: true,
+  checkLoginIframeInterval: 5,
+  enableLogging: false,
+  onLoad: "check-sso",
+  pkceMethod: "S256"
+};
+
+export {
+  KeycloakProvider,
+  defaultKeycloakInitOptions
+};