@multiplatform.one/keycloak 5.0.10 → 5.0.14

package/src/provider/AuthProvider/index.webext.tsx

@@ -0,0 +1,419 @@
+/**
+ * File: /src/provider/AuthProvider/index.electron.tsx
+ * Project: @multiplatform.one/keycloak
+ * File Created: 23-01-2025 16:57:16
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import KeycloakClient from "keycloak-js";
+import type { KeycloakInitOptions } from "keycloak-js";
+import { isIframe, isWindowDefined, logger } from "multiplatform.one";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Loading } from "../../Loading";
+import { useAuthConfig } from "../../hooks";
+import { KeycloakContext } from "../../keycloak/context";
+import { Keycloak, KeycloakConfigContext } from "../../keycloak/index";
+import { persist, useAuthStore } from "../../state";
+import { validOrRefreshableToken } from "../../token";
+import { AfterAuth } from "../AfterAuth";
+import type { AuthProviderProps, MessageSchema, Tokens } from "./shared";
+import { AuthSource, AuthStrategy, defaultKeycloakInitOptions } from "./shared";
+
+export function AuthProvider({
+  children,
+  disabled,
+  keycloakConfig,
+  keycloakInitOptions,
+  loadingComponent,
+}: AuthProviderProps) {
+  const { debug, messageHandlerKeys, iframeSso } = useAuthConfig();
+  const query = new URLSearchParams(
+    isWindowDefined ? window?.location?.search || "" : "",
+  );
+  const authStore = useAuthStore();
+  const [keycloak, setKeycloak] = useState<Keycloak>();
+  const idTokenQuery = query.get("idToken");
+  const refreshTokenQuery = query.get("refreshToken");
+  const tokenQuery = query.get("token");
+  const [listeningRefreshToken, setListeningRefreshToken] = useState(false);
+  const [listeningToken, setListeningToken] = useState(false);
+  const [listeningIdToken, setListeningIdToken] = useState(false);
+  const [loadedMessagePosted, setLoadedMessagePosted] = useState(false);
+  const initialRefreshTokenQuery = useMemo(
+    () =>
+      validOrRefreshableToken(
+        ((!iframeSso && isIframe) ||
+          (typeof refreshTokenQuery === "string"
+            ? refreshTokenQuery || true
+            : undefined)) as string | boolean,
+      ),
+    [refreshTokenQuery, iframeSso],
+  );
+  const initialIdTokenQuery = useMemo(
+    () =>
+      validOrRefreshableToken(
+        ((!iframeSso && isIframe) ||
+          (typeof idTokenQuery === "string"
+            ? idTokenQuery || true
+            : undefined)) as string | boolean,
+        initialRefreshTokenQuery,
+      ),
+    [idTokenQuery, initialRefreshTokenQuery, iframeSso],
+  );
+  const initialTokenQuery = useMemo(
+    () =>
+      validOrRefreshableToken(
+        ((!iframeSso && isIframe) ||
+          (typeof tokenQuery === "string" ? tokenQuery || true : undefined)) as
+          | string
+          | boolean,
+        initialRefreshTokenQuery,
+      ),
+    [tokenQuery, initialRefreshTokenQuery, iframeSso],
+  );
+  const [tokens, setTokens] = useState<Tokens>({
+    refreshToken: initialRefreshTokenQuery,
+    token: initialTokenQuery,
+    idToken: initialIdTokenQuery,
+  });
+  const authSource = useMemo(() => {
+    if (!iframeSso && isIframe && initialTokenQuery) return AuthSource.Query;
+    return AuthSource.Store;
+  }, [initialTokenQuery, iframeSso]);
+  const authStrategy = useMemo(() => {
+    if (authSource === AuthSource.Query) {
+      return AuthStrategy.KeycloakClientImplicit;
+    }
+    if (!persist) return AuthStrategy.KeycloakClientStandard;
+    if (typeof authStore === "undefined") return;
+    if (authStore.token) {
+      if (typeof tokens.token === "undefined") return;
+      if (tokens.token) return AuthStrategy.KeycloakClientImplicit;
+    }
+    return AuthStrategy.KeycloakClientStandard;
+  }, [authSource, authStore?.token, tokens.token]);
+  const isLoading = useMemo(() => {
+    if (!authStrategy) return true;
+    if (authStrategy === AuthStrategy.KeycloakClientImplicit) {
+      if (
+        authSource === AuthSource.Query &&
+        (initialRefreshTokenQuery === true ||
+          initialTokenQuery === true ||
+          initialIdTokenQuery === true)
+      ) {
+        return true;
+      }
+      if (authSource === AuthSource.Store && typeof authStore === "undefined") {
+        return true;
+      }
+    }
+    return false;
+  }, [
+    authSource,
+    authStore?.idToken,
+    authStore?.refreshToken,
+    authStore?.token,
+    authStrategy,
+    initialIdTokenQuery,
+    initialRefreshTokenQuery,
+    initialTokenQuery,
+  ]);
+
+  useEffect(() => {
+    if (
+      !persist ||
+      authStore === undefined ||
+      tokens.idToken ||
+      tokens.refreshToken ||
+      tokens.token
+    ) {
+      return;
+    }
+    const refreshToken = validOrRefreshableToken(authStore.refreshToken);
+    const idToken = validOrRefreshableToken(authStore.idToken, refreshToken);
+    const token = validOrRefreshableToken(authStore.token, refreshToken);
+    if (!idToken && !refreshToken && !token) return;
+    setTokens({
+      idToken: idToken,
+      refreshToken: refreshToken,
+      token: token,
+    });
+  }, [authStore, persist]);
+
+  useEffect(() => {
+    if (
+      disabled ||
+      authSource !== AuthSource.Query ||
+      tokens.token === true ||
+      tokens.refreshToken === true ||
+      tokens.idToken === true ||
+      loadedMessagePosted
+    ) {
+      return;
+    }
+    if (debug) logger.debug("post message", JSON.stringify({ type: "LOADED" }));
+    (messageHandlerKeys || []).forEach((key: string) => {
+      window?.webkit?.messageHandlers?.[key]?.postMessage(
+        JSON.stringify({ type: "LOADED" }),
+      );
+    });
+    window?.ReactNativeWebView?.postMessage(JSON.stringify({ type: "LOADED" }));
+    window?.parent?.postMessage(JSON.stringify({ type: "LOADED" }));
+    setLoadedMessagePosted(true);
+  }, [disabled, authSource, tokens.token, tokens.refreshToken, tokens.idToken]);
+
+  useEffect(() => {
+    if (disabled || tokens.refreshToken !== true || listeningRefreshToken) {
+      return;
+    }
+    setListeningRefreshToken(true);
+    function messageCallback(e: MessageEvent<any>) {
+      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: MessageSchema = data;
+      if (!message.type) return;
+      if (message.type.toUpperCase() === "REFRESH_TOKEN" && message.payload) {
+        if (debug) logger.debug("setting refresh token", message.payload);
+        setTokens((tokens) => ({
+          ...tokens,
+          refreshToken: validOrRefreshableToken(message.payload),
+        }));
+        window.removeEventListener("message", messageCallback);
+        setListeningRefreshToken(false);
+      }
+    }
+    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);
+    };
+  }, [disabled, tokens.refreshToken, listeningRefreshToken]);
+
+  useEffect(() => {
+    if (disabled || tokens.token !== true || listeningToken) return;
+    setListeningToken(true);
+    function messageCallback(e: MessageEvent<any>) {
+      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: MessageSchema = data;
+      if (!message.type) return;
+      if (message.type.toUpperCase() === "TOKEN" && message.payload) {
+        if (debug) logger.debug("setting token", message.payload);
+        setTokens((tokens) => ({
+          ...tokens,
+          token: validOrRefreshableToken(message.payload, tokens.refreshToken),
+        }));
+        window.removeEventListener("message", messageCallback);
+        setListeningToken(false);
+      }
+    }
+    if (debug) {
+      logger.debug(
+        "listening for message",
+        JSON.stringify({
+          type: "TOKEN",
+          payload: "<some_token>",
+        }),
+      );
+    }
+    window.addEventListener("message", messageCallback);
+    return () => {
+      window.removeEventListener("message", messageCallback);
+    };
+  }, [disabled, tokens.token, listeningToken]);
+
+  useEffect(() => {
+    if (disabled || tokens.idToken !== true || listeningIdToken) return;
+    setListeningIdToken(true);
+    function messageCallback(e: MessageEvent<any>) {
+      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: MessageSchema = data;
+      if (!message.type) return;
+      if (message.type.toUpperCase() === "ID_TOKEN" && message.payload) {
+        if (debug) logger.debug("setting id token", message.payload);
+        setTokens((tokens) => ({
+          ...tokens,
+          idToken: validOrRefreshableToken(
+            message.payload,
+            tokens.refreshToken,
+          ),
+        }));
+        window.removeEventListener("message", messageCallback);
+        setListeningIdToken(false);
+      }
+    }
+    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);
+    };
+  }, [disabled, tokens.idToken, listeningIdToken]);
+
+  const keycloakClient = useMemo(
+    () =>
+      !disabled &&
+      !isLoading &&
+      (authStrategy === AuthStrategy.KeycloakClientStandard ||
+        authStrategy === AuthStrategy.KeycloakClientImplicit) &&
+      keycloakConfig
+        ? new KeycloakClient({
+            clientId: keycloakConfig.publicClientId || keycloakConfig.clientId,
+            realm: keycloakConfig.realm,
+            url: keycloakConfig.url,
+          })
+        : undefined,
+    [
+      authStrategy,
+      disabled,
+      isLoading,
+      keycloakConfig,
+      keycloakInitOptions,
+      tokens.idToken,
+      tokens.refreshToken,
+      tokens.token,
+    ],
+  );
+
+  const initOptions = useMemo(() => {
+    if (!keycloakClient) return;
+    const initOptions: KeycloakInitOptions = {
+      ...defaultKeycloakInitOptions,
+      ...keycloakInitOptions,
+      scope: [
+        ...new Set([
+          "email",
+          "openid",
+          "profile",
+          ...(defaultKeycloakInitOptions.scope?.split(" ") || []),
+          ...(keycloakInitOptions?.scope?.split(" ") || []),
+          ...(keycloakConfig.scopes || []),
+        ]),
+      ].join(" "),
+    };
+    if (debug) initOptions.enableLogging = true;
+    if (tokens.token && typeof tokens.token === "string") {
+      initOptions.token = tokens.token;
+      initOptions.timeSkew = 0;
+      if (tokens.idToken && typeof tokens.idToken === "string") {
+        initOptions.idToken = tokens.idToken;
+      }
+      if (tokens.refreshToken && typeof tokens.refreshToken === "string") {
+        initOptions.refreshToken = tokens.refreshToken;
+      }
+    }
+    if ((!iframeSso && isIframe) || (tokens.token && !tokens.refreshToken)) {
+      initOptions.checkLoginIframe = false;
+      initOptions.flow = "implicit";
+      initOptions.onLoad = undefined;
+    }
+    return initOptions;
+  }, [
+    keycloakClient,
+    keycloakInitOptions,
+    keycloakConfig.scopes,
+    debug,
+    tokens.token,
+    tokens.idToken,
+    tokens.refreshToken,
+    iframeSso,
+  ]);
+
+  useEffect(() => {
+    if (
+      !keycloakClient ||
+      !initOptions ||
+      (authStrategy === AuthStrategy.KeycloakClientImplicit &&
+        (typeof tokens.token !== "string" || !tokens.token))
+    ) {
+      return;
+    }
+    function onError() {
+      if (keycloakClient && initOptions) {
+        setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+      }
+    }
+    function onUpdate() {
+      if (keycloakClient && initOptions) {
+        setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+      }
+    }
+    (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 (err) {
+          logger.warn(err);
+          setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+        }
+      };
+      await keycloakClient.init(initOptions);
+      setKeycloak(new Keycloak(keycloakConfig, keycloakClient));
+    })();
+  }, [keycloakClient, initOptions, authStrategy, tokens.token]);
+
+  const render = useCallback(
+    () => (
+      <KeycloakConfigContext.Provider value={keycloakConfig}>
+        <KeycloakContext.Provider value={keycloak}>
+          <AfterAuth loadingComponent={loadingComponent}>{children}</AfterAuth>
+        </KeycloakContext.Provider>
+      </KeycloakConfigContext.Provider>
+    ),
+    [children, keycloak, keycloakConfig],
+  );
+  if (disabled) return <>{children}</>;
+  if (isLoading) return <Loading loadingComponent={loadingComponent} />;
+  return render();
+}

package/src/session/index.electron.ts

@@ -0,0 +1,33 @@
+/*
+ * File: /src/session/index.native.ts
+ * Project: @multiplatform.one/keycloak
+ * File Created: 04-04-2024 15:50:39
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { UseSessionOptions } from "next-auth/react";
+import type { SessionContextValue } from "./index";
+
+export async function getSession() {
+  return null;
+}
+
+export function useSession<R extends boolean>(
+  _options?: UseSessionOptions<R>,
+): SessionContextValue<R> {
+  return {};
+}

package/src/session/index.webext.ts

@@ -0,0 +1,33 @@
+/*
+ * File: /src/session/index.native.ts
+ * Project: @multiplatform.one/keycloak
+ * File Created: 04-04-2024 15:50:39
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { UseSessionOptions } from "next-auth/react";
+import type { SessionContextValue } from "./index";
+
+export async function getSession() {
+  return null;
+}
+
+export function useSession<R extends boolean>(
+  _options?: UseSessionOptions<R>,
+): SessionContextValue<R> {
+  return {};
+}

package/types/Authenticated.d.ts

@@ -0,0 +1,29 @@
+/**
+ * File: /src/Authenticated.tsx
+ * Project: @multiplatform.one/keycloak
+ * File Created: 19-11-2024 20:26:31
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type ComponentType, type PropsWithChildren } from "react";
+export interface AuthenticatedProps extends PropsWithChildren {
+    disabled?: boolean;
+    loadingComponent?: ComponentType;
+    loggedOutComponent?: ComponentType;
+}
+export declare function Authenticated({ children, disabled, loggedOutComponent, loadingComponent, }: AuthenticatedProps): import("react/jsx-runtime").JSX.Element;
+export declare function withAuthenticated<P extends object>(Component: ComponentType<P>, options?: AuthenticatedProps): (props: P) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Authenticated.d.ts.map

package/types/Authenticated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Authenticated.d.ts","sourceRoot":"","sources":["../src/Authenticated.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAa,MAAM,OAAO,CAAC;AAO9E,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,aAAa,CAAC;IACjC,kBAAkB,CAAC,EAAE,aAAa,CAAC;CACpC;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,QAAQ,EACR,kBAAkB,EAClB,gBAAgB,GACjB,EAAE,kBAAkB,2CAoCpB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,OAAO,GAAE,kBAAuB,WAEjB,CAAC,6CAKjB"}

package/types/Loading.d.ts

@@ -0,0 +1,26 @@
+/**
+ * File: /src/Loading.tsx
+ * Project: @multiplatform.one/keycloak
+ * File Created: 01-01-1970 00:00:00
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ComponentType } from "react";
+export interface LoadingProps {
+    loadingComponent?: ComponentType;
+}
+export declare function Loading({ loadingComponent }: LoadingProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Loading.d.ts.map

package/types/Loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loading.d.ts","sourceRoot":"","sources":["../src/Loading.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C,MAAM,WAAW,YAAY;IAC3B,gBAAgB,CAAC,EAAE,aAAa,CAAC;CAClC;AAED,wBAAgB,OAAO,CAAC,EAAE,gBAAgB,EAAE,EAAE,YAAY,2CAOzD"}

package/types/authConfig.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+export declare const defaultAuthConfig: AuthConfig;
+export declare const AuthConfigContext: import("react").Context<AuthConfig>;
+export interface AuthConfig {
+    debug?: boolean;
+    disabled?: boolean;
+    iframeSso?: boolean;
+    loginRedirectUri?: string;
+    messageHandlerKeys?: string[];
+}
+//# sourceMappingURL=authConfig.d.ts.map

package/types/authConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authConfig.d.ts","sourceRoot":"","sources":["../src/authConfig.ts"],"names":[],"mappings":";AAuBA,eAAO,MAAM,iBAAiB,EAAE,UAAe,CAAC;AAEhD,eAAO,MAAM,iBAAiB,qCAA+C,CAAC;AAE9E,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B"}

package/types/hooks/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * File: /src/hooks/index.ts
+ * Project: @multiplatform.one/keycloak
+ * File Created: 19-11-2024 20:26:31
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./useAuthConfig";
+export * from "./useTokensFromQuery/index";
+export * from "./useTokensFromState";
+//# sourceMappingURL=index.d.ts.map

package/types/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC"}

package/types/hooks/useAuthConfig.d.ts

@@ -0,0 +1,2 @@
+export declare function useAuthConfig(): import("../authConfig").AuthConfig;
+//# sourceMappingURL=useAuthConfig.d.ts.map

package/types/hooks/useAuthConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthConfig.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuthConfig.ts"],"names":[],"mappings":"AAwBA,wBAAgB,aAAa,uCAE5B"}

package/types/hooks/useTokensFromQuery/index.d.ts

@@ -0,0 +1,2 @@
+export declare function useTokensFromQuery(): boolean;
+//# sourceMappingURL=index.d.ts.map

package/types/hooks/useTokensFromQuery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTokensFromQuery/index.ts"],"names":[],"mappings":"AAwBA,wBAAgB,kBAAkB,YAWjC"}

package/types/hooks/useTokensFromQuery/index.native.d.ts

@@ -0,0 +1,2 @@
+export declare const useTokensFromQuery: () => boolean;
+//# sourceMappingURL=index.native.d.ts.map

package/types/hooks/useTokensFromQuery/index.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.native.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTokensFromQuery/index.native.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,kBAAkB,eAAc,CAAC"}

package/types/hooks/useTokensFromState.d.ts

@@ -0,0 +1,2 @@
+export declare function useTokensFromStore(): boolean | undefined;
+//# sourceMappingURL=useTokensFromState.d.ts.map

package/types/hooks/useTokensFromState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTokensFromState.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokensFromState.ts"],"names":[],"mappings":"AAwBA,wBAAgB,kBAAkB,wBAIjC"}

package/types/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * File: /src/index.ts
+ * Project: @multiplatform.one/keycloak
+ * File Created: 19-11-2024 20:26:31
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./Authenticated";
+export * from "./authConfig";
+export * from "./hooks/index";
+export * from "./keycloak/index";
+export * from "./provider/index";
+export * from "./session/index";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}