@multiplatform.one/keycloak 0.7.0 → 0.7.2

package/lib/chunk-DJW5IKQS.mjs

@@ -0,0 +1,265 @@
+import {
+  AfterAuth
+} from "./chunk-K2MQYDVB.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
+};

package/lib/chunk-JLIMB5OD.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var _chunkS3M2DZ6Gjs = require("./chunk-S3M2DZ6G.js");
+var _chunk3ZPHNEJLjs = require("./chunk-3ZPHNEJL.js");
+var _chunkC2FNSVJOjs = require("./chunk-C2FNSVJO.js");
+// src/provider/afterAuth.tsx
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+var logger = console;
+var AfterAuth = function(param) {
+    var children = param.children;
+    var authConfig = _chunk3ZPHNEJLjs.useAuthConfig.call(void 0);
+    var authState = _chunkC2FNSVJOjs.useAuthState.call(void 0);
+    var _chunkS3M2DZ6Gjs_useKeycloak_call = _chunkS3M2DZ6Gjs.useKeycloak.call(void 0), token = _chunkS3M2DZ6Gjs_useKeycloak_call.token, refreshToken = _chunkS3M2DZ6Gjs_useKeycloak_call.refreshToken, authenticated = _chunkS3M2DZ6Gjs_useKeycloak_call.authenticated, idToken = _chunkS3M2DZ6Gjs_useKeycloak_call.idToken;
+    _react.useEffect.call(void 0, function() {
+        if (!authenticated) return;
+        if (authConfig.persist && token) {
+            authState.setToken(token);
+            if (idToken) authState.setIdToken(idToken);
+            if (authConfig.ensureFreshness && refreshToken) authState.setRefreshToken(refreshToken);
+        }
+    }, [
+        token,
+        refreshToken,
+        idToken
+    ]);
+    _react.useEffect.call(void 0, function() {
+        if (authConfig.debug && authState.token) logger.debug("token", authState.token);
+    }, [
+        authState.token
+    ]);
+    _react.useEffect.call(void 0, function() {
+        if (authConfig.debug && authState.idToken) logger.debug("idToken", authState.idToken);
+    }, [
+        authState.idToken
+    ]);
+    _react.useEffect.call(void 0, function() {
+        if (authConfig.debug && authState.refreshToken) logger.debug("refreshToken", authState.refreshToken);
+    }, [
+        authState.refreshToken
+    ]);
+    _react.useEffect.call(void 0, function() {
+        if (authConfig.debug) logger.debug("authenticated", authenticated);
+    }, [
+        authenticated
+    ]);
+    return /* @__PURE__ */ _react2.default.createElement(_react2.default.Fragment, null, children);
+};
+exports.AfterAuth = AfterAuth;

package/lib/chunk-JYEIPNPN.mjs

@@ -0,0 +1,76 @@
+import {
+  KeycloakProvider
+} from "./chunk-DJW5IKQS.mjs";
+import {
+  useTokensFromQuery
+} from "./chunk-NXTVYIBR.mjs";
+import {
+  useTokensFromState
+} from "./chunk-UOKDJT5L.mjs";
+import {
+  AuthConfigContext,
+  defaultAuthConfig
+} from "./chunk-64PPU7Q3.mjs";
+
+// src/provider/index.tsx
+import React, { useMemo } from "react";
+import { config } from "app/config";
+var persist = config.get("KEYCLOAK_PERSIST") === "1";
+var AuthProvider = ({
+  // keycloak config
+  realm,
+  clientId,
+  baseUrl,
+  // auth config
+  debug,
+  ensureFreshness,
+  loginRoute,
+  messageHandlerKeys,
+  ssr,
+  // props
+  children,
+  cookies,
+  disabled,
+  loadingComponent,
+  onEvent,
+  onTokens,
+  ...keycloakInitOptions
+}) => {
+  const tokensFromQuery = useTokensFromQuery();
+  const tokensFromState = useTokensFromState();
+  const authConfig = useMemo(
+    () => ({
+      ...defaultAuthConfig,
+      ...typeof debug !== "undefined" ? { debug } : {},
+      ...typeof ensureFreshness !== "undefined" ? { ensureFreshness } : {},
+      ...typeof loginRoute !== "undefined" ? { loginRoute } : {},
+      ...typeof messageHandlerKeys !== "undefined" ? { messageHandlerKeys } : {},
+      persist: !tokensFromState && !tokensFromQuery && cookies && ssr ? false : typeof persist !== "undefined" ? persist : defaultAuthConfig.persist,
+      ssr: !tokensFromState && !tokensFromQuery && cookies ? typeof ssr !== "undefined" ? ssr : defaultAuthConfig.ssr : false
+    }),
+    [debug, ensureFreshness, loginRoute, messageHandlerKeys, persist, ssr]
+  );
+  if (disabled) {
+    return /* @__PURE__ */ React.createElement(AuthConfigContext.Provider, { value: authConfig }, children);
+  }
+  return /* @__PURE__ */ React.createElement(AuthConfigContext.Provider, { value: authConfig }, /* @__PURE__ */ React.createElement(
+    KeycloakProvider,
+    {
+      cookies,
+      keycloakConfig: {
+        realm: realm || "main",
+        clientId: clientId || "app",
+        url: baseUrl
+      },
+      keycloakInitOptions,
+      loadingComponent,
+      onEvent,
+      onTokens
+    },
+    children
+  ));
+};
+
+export {
+  AuthProvider
+};

package/lib/chunk-K2MQYDVB.mjs

@@ -0,0 +1,50 @@
+import {
+  useKeycloak
+} from "./chunk-BTHRDOLL.mjs";
+import {
+  useAuthConfig
+} from "./chunk-Y4XMF3R6.mjs";
+import {
+  useAuthState
+} from "./chunk-AD6VPMID.mjs";
+
+// src/provider/afterAuth.tsx
+import React, { useEffect } from "react";
+var logger = console;
+var AfterAuth = ({ children }) => {
+  const authConfig = useAuthConfig();
+  const authState = useAuthState();
+  const { token, refreshToken, authenticated, idToken } = useKeycloak();
+  useEffect(() => {
+    if (!authenticated)
+      return;
+    if (authConfig.persist && token) {
+      authState.setToken(token);
+      if (idToken)
+        authState.setIdToken(idToken);
+      if (authConfig.ensureFreshness && refreshToken)
+        authState.setRefreshToken(refreshToken);
+    }
+  }, [token, refreshToken, idToken]);
+  useEffect(() => {
+    if (authConfig.debug && authState.token)
+      logger.debug("token", authState.token);
+  }, [authState.token]);
+  useEffect(() => {
+    if (authConfig.debug && authState.idToken)
+      logger.debug("idToken", authState.idToken);
+  }, [authState.idToken]);
+  useEffect(() => {
+    if (authConfig.debug && authState.refreshToken)
+      logger.debug("refreshToken", authState.refreshToken);
+  }, [authState.refreshToken]);
+  useEffect(() => {
+    if (authConfig.debug)
+      logger.debug("authenticated", authenticated);
+  }, [authenticated]);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+};
+
+export {
+  AfterAuth
+};

package/lib/chunk-KLLABHIC.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+}); // src/hooks/useTokensFromQuery/index.ts
+var _multiplatformone = require("multiplatform.one");
+var _router = require("next/router");
+function useTokensFromQuery() {
+    var query = (_multiplatformone.MultiPlatform.isNext ? _router.useRouter.call(void 0) : {
+        query: {}
+    }).query;
+    return "idToken" in query || "token" in query || "refreshToken" in query;
+}
+exports.useTokensFromQuery = useTokensFromQuery;

package/lib/chunk-L5HMOY4M.mjs

@@ -0,0 +1,18 @@
+// src/hooks/useCurrentRouteName/index.ts
+import { MultiPlatform } from "multiplatform.one";
+import { useRoute } from "@react-navigation/native";
+import { useRouter } from "next/router";
+function useCurrentRouteName() {
+  if (MultiPlatform.isStorybook)
+    return null;
+  if (MultiPlatform.isNext) {
+    const router = useRouter();
+    return router.route;
+  }
+  const route = useRoute();
+  return route.name;
+}
+
+export {
+  useCurrentRouteName
+};

package/lib/chunk-NHABU752.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+export {
+  __publicField
+};

package/lib/chunk-NRD376XV.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _chunkOYWAYMFNjs = require("./chunk-OYWAYMFN.js");
+var _chunkS3M2DZ6Gjs = require("./chunk-S3M2DZ6G.js");
+var _chunk3ZPHNEJLjs = require("./chunk-3ZPHNEJL.js");
+// src/hooks/useLogin.ts
+var _multiplatformone = require("multiplatform.one");
+var _router = require("solito/router");
+function useLogin(loginRoute) {
+    if (_multiplatformone.MultiPlatform.isStorybook) return function() {
+        return null;
+    };
+    var keycloak = _chunkS3M2DZ6Gjs.useKeycloak.call(void 0);
+    var authConfig = _chunk3ZPHNEJLjs.useAuthConfig.call(void 0);
+    var currentRouteName = _chunkOYWAYMFNjs.useCurrentRouteName.call(void 0);
+    var router = _router.useRouter.call(void 0);
+    return function() {
+        if (!loginRoute) loginRoute = authConfig.loginRoute;
+        if (!loginRoute) {
+            keycloak.login();
+            return;
+        }
+        var url = new URL("x://".concat(loginRoute));
+        var searchParams = new URLSearchParams(url.search);
+        if (currentRouteName) searchParams.append("backTo", currentRouteName);
+        var query = searchParams.toString();
+        if (query.length) query = "?".concat(query);
+        router.push("".concat(url.pathname.substring(2)).concat(query));
+    };
+}
+exports.useLogin = useLogin;

package/lib/chunk-NWRANDZ6.js

@@ -0,0 +1,98 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _optionalChain(ops) {
+    var lastAccessLHS = undefined;
+    var value = ops[0];
+    var i = 1;
+    while(i < ops.length){
+        var op = ops[i];
+        var fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+            return undefined;
+        }
+        if (op === "access" || op === "optionalAccess") {
+            lastAccessLHS = value;
+            value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+            var _value;
+            value = fn(function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return (_value = value).call.apply(_value, [
+                    lastAccessLHS
+                ].concat(_to_consumable_array(args)));
+            });
+            lastAccessLHS = undefined;
+        }
+    }
+    return value;
+} // src/util.ts
+function validToken(token, refreshToken) {
+    if (typeof token !== "string") return token;
+    if (refreshToken) {
+        if (refreshToken === true || isTokenValid(refreshToken)) return token;
+        return false;
+    }
+    return isTokenValid(token) ? token : false;
+}
+function isTokenValid(token) {
+    try {
+        var exp = JSON.parse(Buffer.from(_optionalChain([
+            token,
+            "access",
+            function(_) {
+                return _.split;
+            },
+            "call",
+            function(_2) {
+                return _2(".");
+            },
+            "optionalAccess",
+            function(_3) {
+                return _3[1];
+            }
+        ]) || "", "base64").toString() || "{}").exp;
+        return Math.floor(Date.now() / 1e3) <= exp;
+    } catch (err) {
+        if (_instanceof(err, SyntaxError)) return false;
+        throw err;
+    }
+}
+exports.validToken = validToken;
+exports.isTokenValid = isTokenValid;

package/lib/chunk-NXTVYIBR.mjs

@@ -0,0 +1,11 @@
+// src/hooks/useTokensFromQuery/index.ts
+import { MultiPlatform } from "multiplatform.one";
+import { useRouter } from "next/router";
+function useTokensFromQuery() {
+  const { query } = MultiPlatform.isNext ? useRouter() : { query: {} };
+  return "idToken" in query || "token" in query || "refreshToken" in query;
+}
+
+export {
+  useTokensFromQuery
+};

package/lib/chunk-OYWAYMFN.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+}); // src/hooks/useCurrentRouteName/index.ts
+var _multiplatformone = require("multiplatform.one");
+var _native = require("@react-navigation/native");
+var _router = require("next/router");
+function useCurrentRouteName() {
+    if (_multiplatformone.MultiPlatform.isStorybook) return null;
+    if (_multiplatformone.MultiPlatform.isNext) {
+        var router = _router.useRouter.call(void 0);
+        return router.route;
+    }
+    var route = _native.useRoute.call(void 0);
+    return route.name;
+}
+exports.useCurrentRouteName = useCurrentRouteName;