@multiplatform.one/keycloak 1.0.4 → 1.0.6

package/dist/esm/provider/AuthProvider/AuthProvider.mjs

@@ -0,0 +1,164 @@
+"use client";
+
+import KeycloakClient from "keycloak-js";
+import { useEffect, useMemo, useState } from "react";
+import { AfterAuth } from "../AfterAuth.mjs";
+import { Keycloak, KeycloakConfigContext } from "../../keycloak/index.mjs";
+import { KeycloakContext } from "../../keycloak/context.mjs";
+import { MultiPlatform } from "multiplatform.one";
+import { SessionProvider } from "next-auth/react";
+import { persist, useAuthState } from "../../state.mjs";
+import { useAuthConfig } from "../../hooks/index.mjs";
+import { useRouter } from "next/router";
+import { validOrRefreshableToken } from "../../token.mjs";
+import { jsx } from "react/jsx-runtime";
+const logger = console;
+function AuthProvider({
+  children,
+  sessionProvider,
+  keycloakInitOptions,
+  keycloakConfig
+}) {
+  const {
+      debug,
+      messageHandlerKeys
+    } = useAuthConfig(),
+    {
+      query
+    } = MultiPlatform.isNext ? useRouter() : {
+      query: {}
+    },
+    authState = useAuthState(),
+    [keycloak, setKeycloak] = useState(),
+    initialRefreshToken = useMemo(() => validOrRefreshableToken(MultiPlatform.isIframe ? "refreshToken" in query && (query.refreshToken?.toString() || !0) || persist && authState.refreshToken || !1 : void 0), []),
+    [tokens, setTokens] = useState({
+      refreshToken: initialRefreshToken,
+      token: validOrRefreshableToken(MultiPlatform.isIframe ? "token" in query && (query.token?.toString() || !0) || persist && authState.token || !1 : void 0, initialRefreshToken),
+      idToken: validOrRefreshableToken(MultiPlatform.isIframe ? "idToken" in query && (query.idToken?.toString() || !0) || persist && authState.idToken || !1 : void 0, initialRefreshToken)
+    });
+  useEffect(() => {
+    tokens.token !== !0 && tokens.refreshToken !== !0 && tokens.idToken !== !0 || (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 (tokens.refreshToken !== !0) return;
+    const messageCallback = e => {
+      let data = e?.data || null;
+      if (typeof data == "string") try {
+        data = JSON.parse(data);
+      } catch {}
+      debug && logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      message.type && message.type.toUpperCase() === "REFRESH_TOKEN" && message.payload && (debug && logger.debug("setting refresh token", message.payload), setTokens(tokens2 => ({
+        ...tokens2,
+        refreshToken: validOrRefreshableToken(message.payload)
+      })), window.removeEventListener("message", messageCallback));
+    };
+    return debug && logger.debug("listening for message", JSON.stringify({
+      type: "REFRESH_TOKEN",
+      payload: "<some_refresh_token>"
+    })), window.addEventListener("message", messageCallback), () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []), useEffect(() => {
+    if (tokens.token !== !0) return;
+    const messageCallback = e => {
+      let data = e?.data || null;
+      if (typeof data == "string") try {
+        data = JSON.parse(data);
+      } catch {}
+      debug && logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      message.type && message.type.toUpperCase() === "TOKEN" && message.payload && (debug && logger.debug("setting token", message.payload), setTokens(tokens2 => ({
+        ...tokens2,
+        token: validOrRefreshableToken(message.payload, tokens2.refreshToken)
+      })), window.removeEventListener("message", messageCallback));
+    };
+    return debug && logger.debug("listening for message", JSON.stringify({
+      type: "TOKEN",
+      payload: "<some_token>"
+    })), window.addEventListener("message", messageCallback), () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []), useEffect(() => {
+    if (tokens.idToken !== !0) return;
+    const messageCallback = e => {
+      let data = e?.data || null;
+      if (typeof data == "string") try {
+        data = JSON.parse(data);
+      } catch {}
+      debug && logger.debug("received message", JSON.stringify(data));
+      const message = data;
+      message.type && message.type.toUpperCase() === "ID_TOKEN" && message.payload && (debug && logger.debug("setting id token", message.payload), setTokens(tokens2 => ({
+        ...tokens2,
+        idToken: validOrRefreshableToken(message.payload, tokens2.refreshToken)
+      })), window.removeEventListener("message", messageCallback));
+    };
+    return debug && logger.debug("listening for message", JSON.stringify({
+      type: "ID_TOKEN",
+      payload: "<some_id_token>"
+    })), window.addEventListener("message", messageCallback), () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, []);
+  const keycloakClient = useMemo(() => MultiPlatform.isIframe && keycloakConfig ? new KeycloakClient({
+      url: keycloakConfig.url,
+      realm: keycloakConfig.realm,
+      clientId: keycloakConfig.publicClientId || keycloakConfig.clientId
+    }) : void 0, [keycloakInitOptions, keycloakConfig, tokens.token, tokens.refreshToken, tokens.idToken]),
+    initOptions = useMemo(() => {
+      if (!MultiPlatform.isIframe) return;
+      const initOptions2 = {
+        ...defaultKeycloakInitOptions,
+        ...keycloakInitOptions,
+        scope: [... /* @__PURE__ */new Set(["email", "openid", "profile", ...(defaultKeycloakInitOptions.scope?.split(" ") || []), ...(keycloakInitOptions?.scope?.split(" ") || []), ...(keycloakConfig.scopes || [])])].join(" ")
+      };
+      return debug && (initOptions2.enableLogging = !0), tokens.token && typeof tokens.token == "string" && (initOptions2.token = tokens.token, initOptions2.timeSkew = 0, tokens.idToken && typeof tokens.idToken == "string" && (initOptions2.idToken = tokens.idToken), tokens.refreshToken && typeof tokens.refreshToken == "string" && (initOptions2.refreshToken = tokens.refreshToken)), (typeof window < "u" && window.self !== window.top || tokens.token && !tokens.refreshToken) && (initOptions2.checkLoginIframe = !1, initOptions2.flow = "implicit", initOptions2.onLoad = void 0), initOptions2;
+    }, [keycloakInitOptions, keycloakConfig.scopes, tokens.token, tokens.idToken, tokens.refreshToken]);
+  return useEffect(() => {
+    function onError() {
+      keycloakClient && initOptions && setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+    }
+    function onUpdate() {
+      keycloakClient && initOptions && setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+    }
+    keycloakClient && initOptions && (async () => {
+      keycloakClient.onAuthError = onError, keycloakClient.onAuthLogout = onUpdate, keycloakClient.onAuthRefreshError = onError, keycloakClient.onAuthRefreshSuccess = onUpdate, keycloakClient.onAuthSuccess = onUpdate, keycloakClient.onReady = onUpdate, keycloakClient.onTokenExpired = async () => {
+        try {
+          await keycloakClient.updateToken(5);
+        } catch {
+          setKeycloak(new Keycloak(keycloakConfig));
+        }
+      };
+      const authenticated = await keycloakClient.init(initOptions);
+      setKeycloak(new Keycloak(keycloakConfig, authenticated ? keycloakClient : void 0));
+    })();
+  }, []), /* @__PURE__ */jsx(SessionProvider, {
+    ...sessionProvider,
+    children: /* @__PURE__ */jsx(KeycloakConfigContext.Provider, {
+      value: keycloakConfig,
+      children: /* @__PURE__ */jsx(KeycloakContext.Provider, {
+        value: keycloak,
+        children: /* @__PURE__ */jsx(AfterAuth, {
+          children
+        })
+      })
+    })
+  });
+}
+const defaultKeycloakInitOptions = {
+  checkLoginIframe: !0,
+  checkLoginIframeInterval: 5,
+  enableLogging: !1,
+  onLoad: "check-sso",
+  pkceMethod: "S256"
+};
+export { AuthProvider };

package/dist/esm/provider/AuthProvider/AuthProvider.native.js

@@ -0,0 +1,401 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useMemo, useCallback } from "react";
+import { AfterAuth } from "../AfterAuth";
+import { Keycloak, KeycloakConfigContext } from "../../keycloak";
+import { KeycloakContext } from "../../keycloak/context";
+import { makeRedirectUri, useAuthRequest, useAutoDiscovery, refreshAsync, exchangeCodeAsync } from "expo-auth-session";
+import { persist, useAuthState } from "../../state";
+import { validOrRefreshableToken, isTokenExpired } from "../../token";
+function _array_like_to_array(arr, len) {
+  (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_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+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) {
+    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), 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);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+var REFRESH_THRESHOLD = 5;
+function AuthProvider(param) {
+  var children = param.children, keycloakConfig = param.keycloakConfig, _response_params, _useState = _sliced_to_array(useState(), 2), keycloak = _useState[0], setKeycloak = _useState[1], authState = useAuthState(), initialRefreshToken = useMemo(function() {
+    return validOrRefreshableToken(persist && authState.refreshToken || !1);
+  }, []), keycloakUrl = "".concat(keycloakConfig == null ? void 0 : keycloakConfig.url, "/realms/").concat(keycloakConfig == null ? void 0 : keycloakConfig.realm), clientId = keycloakConfig.publicClientId || (keycloakConfig == null ? void 0 : keycloakConfig.clientId) || "", discovery = useAutoDiscovery(keycloakUrl), redirectUri = makeRedirectUri(), _useState1 = _sliced_to_array(useState({
+    refreshToken: initialRefreshToken,
+    token: validOrRefreshableToken(persist && authState.token || !1, initialRefreshToken),
+    idToken: validOrRefreshableToken(persist && authState.idToken || !1, initialRefreshToken)
+  }), 2), tokens = _useState1[0], setTokens = _useState1[1], scopes = useMemo(function() {
+    return _to_consumable_array(new Set([
+      "email",
+      "openid",
+      "profile"
+    ].concat(_to_consumable_array(keycloakConfig.scopes || []))));
+  }, [
+    keycloakConfig.scopes
+  ]), _useAuthRequest = _sliced_to_array(useAuthRequest({
+    clientId,
+    redirectUri,
+    scopes
+  }, discovery), 3), request = _useAuthRequest[0], response = _useAuthRequest[1], promptAsync = _useAuthRequest[2];
+  useEffect(function() {
+    !discovery || !(response != null && response.type) || !(request != null && request.codeVerifier) || !clientId || _async_to_generator(function() {
+      var tokenResponse;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return (response == null ? void 0 : response.type) === "success" && request.codeVerifier && response.params.code ? [
+              4,
+              exchangeCodeAsync({
+                clientId,
+                code: response.params.code,
+                redirectUri,
+                scopes,
+                extraParams: {
+                  code_verifier: request.codeVerifier
+                }
+              }, discovery)
+            ] : [
+              3,
+              2
+            ];
+          case 1:
+            tokenResponse = _state.sent(), tokenResponse && setTokens({
+              idToken: tokenResponse.idToken,
+              refreshToken: tokenResponse.refreshToken,
+              token: tokenResponse.accessToken
+            }), _state.label = 2;
+          case 2:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  }, [
+    !discovery,
+    request == null ? void 0 : request.codeVerifier,
+    (response == null ? void 0 : response.type) === "success" ? response == null || (_response_params = response.params) === null || _response_params === void 0 ? void 0 : _response_params.code : void 0,
+    clientId,
+    scopes,
+    redirectUri
+  ]);
+  var resetTokens = useCallback(function() {
+    authState.setIdToken(""), authState.setRefreshToken(""), authState.setToken(""), setTokens({
+      refreshToken: void 0,
+      token: void 0,
+      idToken: void 0
+    });
+  }, []), refreshTokens = useCallback(/* @__PURE__ */ _async_to_generator(function() {
+    var tokenResponse;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return discovery ? typeof tokens.refreshToken != "string" ? [
+            3,
+            4
+          ] : isTokenExpired(tokens.refreshToken) ? [
+            3,
+            2
+          ] : [
+            4,
+            refreshAsync({
+              clientId,
+              refreshToken: tokens.refreshToken,
+              scopes
+            }, discovery)
+          ] : [
+            2
+          ];
+        case 1:
+          return tokenResponse = _state.sent(), tokenResponse ? setTokens({
+            idToken: tokenResponse.idToken,
+            refreshToken: tokenResponse.refreshToken,
+            token: tokenResponse.accessToken
+          }) : resetTokens(), [
+            3,
+            3
+          ];
+        case 2:
+          resetTokens(), _state.label = 3;
+        case 3:
+          return [
+            3,
+            5
+          ];
+        case 4:
+          authState.refreshToken && typeof authState.refreshToken == "string" && isTokenExpired(authState.refreshToken) && resetTokens(), _state.label = 5;
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  }), [
+    !discovery,
+    tokens.refreshToken,
+    clientId,
+    scopes
+  ]);
+  return useEffect(function() {
+    discovery && refreshTokens();
+  }, [
+    !discovery
+  ]), useEffect(function() {
+    if (request) {
+      var refreshHandle;
+      return _async_to_generator(function() {
+        var _keycloak_tokenParsed, _keycloak, _keycloak_refreshTokenParsed, timeout;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return tokens.token && isTokenExpired(tokens.token) ? [
+                4,
+                refreshTokens()
+              ] : [
+                3,
+                2
+              ];
+            case 1:
+              return _state.sent(), [
+                3,
+                3
+              ];
+            case 2:
+              if (_keycloak = new Keycloak(keycloakConfig, tokens.token || void 0, tokens.idToken || void 0, tokens.refreshToken || void 0, function() {
+                var _ref = _async_to_generator(function(options) {
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          promptAsync(options)
+                        ];
+                      case 1:
+                        return _state2.sent(), [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(options) {
+                  return _ref.apply(this, arguments);
+                };
+              }(), function() {
+                var _ref = _async_to_generator(function(_options) {
+                  return _ts_generator(this, function(_state2) {
+                    return resetTokens(), [
+                      2
+                    ];
+                  });
+                });
+                return function(_options) {
+                  return _ref.apply(this, arguments);
+                };
+              }()), !((_keycloak_tokenParsed = _keycloak.tokenParsed) === null || _keycloak_tokenParsed === void 0) && _keycloak_tokenParsed.exp)
+                if (timeout = Math.max(Math.min(_keycloak.tokenParsed.exp, ((_keycloak_refreshTokenParsed = _keycloak.refreshTokenParsed) === null || _keycloak_refreshTokenParsed === void 0 ? void 0 : _keycloak_refreshTokenParsed.exp) || 0) - Math.floor(Date.now() / 1e3) - REFRESH_THRESHOLD, REFRESH_THRESHOLD) * 1e3, timeout > 0)
+                  refreshHandle = setTimeout(function() {
+                    refreshTokens();
+                  }, timeout);
+                else
+                  return setTimeout(function() {
+                    return _keycloak.logout();
+                  }, Math.max(0, timeout + REFRESH_THRESHOLD) * 1e3), [
+                    2
+                  ];
+              setKeycloak(_keycloak), _state.label = 3;
+            case 3:
+              return [
+                2
+              ];
+          }
+        });
+      })(), function() {
+        refreshHandle && clearTimeout(refreshHandle);
+      };
+    }
+  }, [
+    !request,
+    tokens.token,
+    tokens.idToken,
+    tokens.refreshToken,
+    refreshTokens
+  ]), /* @__PURE__ */ _jsx(KeycloakConfigContext.Provider, {
+    value: keycloakConfig,
+    children: /* @__PURE__ */ _jsx(KeycloakContext.Provider, {
+      value: keycloak,
+      children: /* @__PURE__ */ _jsx(AfterAuth, {
+        children
+      })
+    })
+  });
+}
+export {
+  AuthProvider
+};
+//# sourceMappingURL=AuthProvider.native.js.map

package/dist/esm/provider/AuthProvider/AuthProvider.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/provider/AuthProvider/home/phani25/Projects/Bitspur/Internal/multiplatform.one/multiplatform.one/packages/keycloak/src/provider/AuthProvider/AuthProvider.native.tsx"],
+  "mappings": "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",
+  "names": ["useState", "useEffect", "useMemo", "useCallback", "AfterAuth", "Keycloak", "KeycloakConfigContext", "KeycloakContext", "makeRedirectUri", "useAuthRequest", "useAutoDiscovery", "refreshAsync", "exchangeCodeAsync", "persist", "useAuthState", "validOrRefreshableToken", "isTokenExpired", "REFRESH_THRESHOLD", "AuthProvider", "children", "keycloakConfig", "response", "keycloak", "setKeycloak", "authState", "initialRefreshToken", "refreshToken", "keycloakUrl", "url", "realm", "clientId", "publicClientId", "discovery", "redirectUri", "token", "idToken", "tokens", "setTokens", "scopes", "Set", "request", "promptAsync", "type", "codeVerifier", "tokenResponse", "params", "code", "extraParams", "code_verifier", "accessToken", "undefined", "resetTokens", "setIdToken", "setRefreshToken", "setToken", "refreshTokens", "refreshHandle", "_keycloak", "timeout", "options", "_state", "_options", "tokenParsed", "exp", "Math", "max", "min", "refreshTokenParsed", "floor", "Date", "now", "setTimeout", "logout", "clearTimeout", "Provider", "value"]
+}

package/dist/esm/provider/AuthProvider/index.js

@@ -0,0 +1,2 @@
+export * from "./AuthProvider";
+//# sourceMappingURL=index.js.map

package/dist/esm/provider/AuthProvider/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/provider/AuthProvider/index.ts"],
+  "mappings": "AAqBA,cAAc;",
+  "names": []
+}

package/dist/esm/provider/AuthProvider/index.mjs

@@ -0,0 +1 @@
+export * from "./AuthProvider.mjs";

package/dist/esm/provider/AuthProvider/index.native.js

@@ -0,0 +1,2 @@
+export * from "./AuthProvider";
+//# sourceMappingURL=index.js.map

package/dist/esm/provider/AuthProvider/index.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/provider/AuthProvider/home/phani25/Projects/Bitspur/Internal/multiplatform.one/multiplatform.one/packages/keycloak/src/provider/AuthProvider/index.ts"],
+  "mappings": "AAqBA,cAAc;",
+  "names": []
+}

package/dist/esm/provider/KeycloakProvider.js

@@ -0,0 +1,32 @@
+import { useMemo } from "react";
+import { AuthConfigContext } from "../authConfig";
+import { AuthProvider } from "./AuthProvider";
+import { jsx } from "react/jsx-runtime";
+function KeycloakProvider({
+  children,
+  debug,
+  realm,
+  clientId,
+  baseUrl,
+  publicClientId,
+  session
+}) {
+  const authConfig = useMemo(() => ({ debug }), [debug]);
+  return /* @__PURE__ */ jsx(AuthConfigContext.Provider, { value: authConfig, children: /* @__PURE__ */ jsx(
+    AuthProvider,
+    {
+      sessionProvider: { session },
+      keycloakConfig: {
+        clientId: clientId || "app",
+        publicClientId,
+        realm: realm || "main",
+        url: baseUrl
+      },
+      children
+    }
+  ) });
+}
+export {
+  KeycloakProvider
+};
+//# sourceMappingURL=KeycloakProvider.js.map

package/dist/esm/provider/KeycloakProvider.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/provider/KeycloakProvider.tsx"],
+  "mappings": "AAqBA,SAAgB,eAAe;AAI/B,SAAS,yBAAyB;AAClC,SAAS,oBAAoB;AAuBvB;AAbC,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA0B;AACxB,QAAM,aAAa,QAAQ,OAAO,EAAE,MAAM,IAAI,CAAC,KAAK,CAAC;AAErD,SACE,oBAAC,kBAAkB,UAAlB,EAA2B,OAAO,YACjC;AAAA,IAAC;AAAA;AAAA,MACC,iBAAiB,EAAE,QAAQ;AAAA,MAC3B,gBAAgB;AAAA,QACd,UAAU,YAAY;AAAA,QACtB;AAAA,QACA,OAAO,SAAS;AAAA,QAChB,KAAK;AAAA,MACP;AAAA,MAEC;AAAA;AAAA,EACH,GACF;AAEJ;",
+  "names": []
+}

package/dist/esm/provider/KeycloakProvider.mjs

@@ -0,0 +1,33 @@
+import { useMemo } from "react";
+import { AuthConfigContext } from "../authConfig.mjs";
+import { AuthProvider } from "./AuthProvider/index.mjs";
+import { jsx } from "react/jsx-runtime";
+function KeycloakProvider({
+  children,
+  debug,
+  realm,
+  clientId,
+  baseUrl,
+  publicClientId,
+  session
+}) {
+  const authConfig = useMemo(() => ({
+    debug
+  }), [debug]);
+  return /* @__PURE__ */jsx(AuthConfigContext.Provider, {
+    value: authConfig,
+    children: /* @__PURE__ */jsx(AuthProvider, {
+      sessionProvider: {
+        session
+      },
+      keycloakConfig: {
+        clientId: clientId || "app",
+        publicClientId,
+        realm: realm || "main",
+        url: baseUrl
+      },
+      children
+    })
+  });
+}
+export { KeycloakProvider };