@enterprisestandard/react 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+import { type IAM } from './iam';
 import { SSOManager } from './sso';
 import { type Vault } from './vault';
-import { type IAM } from './iam';
 export type EnterpriseStandard = {
     ioniteUrl: string;
     appId: string;
@@ -18,4 +18,7 @@ export declare function enterpriseStandard(appId: string, appKey?: string, initC
 export type * from './enterprise-user';
 export { oidcCallbackSchema } from './oidc-schema';
 export * from './server';
-export { useUser } from './useUser';
+export { SignInLoading } from './ui/sign-in-loading';
+export { SignedIn } from './ui/signed-in';
+export { SignedOut } from './ui/signed-out';
+export * from './ui/sso-provider';

package/dist/index.js

@@ -1,3 +1,12 @@
+// src/iam.ts
+async function iam(config) {
+  return {
+    url: config.url,
+    userEndpoint: config.userEndpoint,
+    groupEndpoint: config.groupEndpoint
+  };
+}
+
 // src/utils.ts
 var defaultInstance;
 function must(value, message = "Assertion failed. Required value is null or undefined.") {
@@ -28,7 +37,7 @@ class SSOManager {
   constructor(config) {
     this.config = {
       ...config,
-      secure: config.secure === undefined || config.secure === true ? true : false,
+      secure: !!(config.secure === undefined || config.secure === true),
       sameSite: config.sameSite === undefined || config.sameSite === "Strict" ? "Strict" : "Lax",
       cookiePrefix: config.cookiePrefix ?? `es.sso.${config.client_id}`,
       cookiePath: config.cookiePath ?? "/"
@@ -124,12 +133,10 @@ class SSOManager {
         if (errorPage) {
           return new Response("Redirecting to error page", {
             status: 302,
-            headers: [
-              ["Location", errorPage]
-            ]
+            headers: [["Location", errorPage]]
           });
         }
-      } catch (err) {
+      } catch (_err) {
         console.warn("Error parsing the errorPage from the OIDC cookie");
       }
       console.warn("No error page was found in the cookies. The user will be shown a default error page.");
@@ -148,10 +155,12 @@ class SSOManager {
       userName: idToken.preferred_username || "",
       name: idToken.name || "",
       email: idToken.email || "",
-      emails: [{
-        value: idToken.email || "",
-        primary: true
-      }],
+      emails: [
+        {
+          value: idToken.email || "",
+          primary: true
+        }
+      ],
       avatarUrl: idToken.picture,
       sso: {
         profile: {
@@ -396,15 +405,6 @@ async function vault(url, token) {
   };
 }
 
-// src/iam.ts
-async function iam(config) {
-  return {
-    url: config.url,
-    userEndpoint: config.userEndpoint,
-    groupEndpoint: config.groupEndpoint
-  };
-}
-
 // src/oidc-schema.ts
 function oidcCallbackSchema(vendor) {
   return {
@@ -544,33 +544,177 @@ async function callback(request, es) {
     throw unavailable();
   return sso.callbackHandler(request);
 }
-// src/useUser.ts
-import { useState, useEffect } from "react";
-function useUser(apiUrl) {
-  const [isLoading, setIsLoading] = useState(true);
-  const [user, setUser] = useState(undefined);
-  const [status, setStatus] = useState(undefined);
-  const resolvedApiUrl = apiUrl || "/api/user";
+// src/ui/sign-in-loading.tsx
+import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
+function SignInLoading({ children }) {
+  const { isLoading } = useUser();
+  if (isLoading)
+    return /* @__PURE__ */ jsxDEV(Fragment, {
+      children
+    }, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV(Fragment, {}, undefined, false, undefined, this);
+}
+// src/ui/signed-in.tsx
+import { jsxDEV as jsxDEV2, Fragment as Fragment2 } from "react/jsx-dev-runtime";
+function SignedIn({ children }) {
+  const { user } = useUser();
+  if (user)
+    return /* @__PURE__ */ jsxDEV2(Fragment2, {
+      children
+    }, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV2(Fragment2, {}, undefined, false, undefined, this);
+}
+// src/ui/signed-out.tsx
+import { jsxDEV as jsxDEV3, Fragment as Fragment3 } from "react/jsx-dev-runtime";
+function SignedOut({ children }) {
+  const { user } = useUser();
+  if (user)
+    return /* @__PURE__ */ jsxDEV3(Fragment3, {}, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV3(Fragment3, {
+    children
+  }, undefined, false, undefined, this);
+}
+// src/ui/sso-provider.tsx
+import { createContext, useCallback, useContext, useEffect, useState } from "react";
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+var SSOContext = createContext(undefined);
+var generateStorageKey = (tenantId) => {
+  return `es-sso-user-${tenantId.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}`;
+};
+function SSOProvider({
+  tenantId,
+  storage = "memory",
+  storageKey,
+  userUrl,
+  disableListener = false,
+  children
+}) {
+  const [user, setUserState] = useState(null);
+  const [isLoading, setIsLoading] = useState(!!userUrl);
+  const actualStorageKey = storageKey || (tenantId ? generateStorageKey(tenantId) : "es-sso-user");
+  const isValidUser = useCallback((user2) => {
+    if (!user2 || !tenantId)
+      return true;
+    return user2.sso?.tenant?.id === tenantId;
+  }, [tenantId]);
+  const loadUserFromStorage = useCallback(() => {
+    if (storage === "memory")
+      return null;
+    try {
+      const storageObject = storage === "local" ? localStorage : sessionStorage;
+      const userData = storageObject.getItem(actualStorageKey);
+      if (!userData)
+        return null;
+      const parsedUser = JSON.parse(userData);
+      if (parsedUser.sso?.expires) {
+        parsedUser.sso.expires = new Date(parsedUser.sso.expires);
+      }
+      return isValidUser(parsedUser) ? parsedUser : null;
+    } catch (error) {
+      console.error("Error loading user from storage:", error);
+      return null;
+    }
+  }, [storage, actualStorageKey, isValidUser]);
+  const saveUserToStorage = useCallback((user2) => {
+    if (storage === "memory")
+      return;
+    try {
+      const storageObject = storage === "local" ? localStorage : sessionStorage;
+      if (user2 === null) {
+        storageObject.removeItem(actualStorageKey);
+      } else {
+        storageObject.setItem(actualStorageKey, JSON.stringify(user2));
+      }
+    } catch (error) {
+      console.error("Error saving user to storage:", error);
+    }
+  }, [storage, actualStorageKey]);
+  const setUser = useCallback((newUser) => {
+    if (newUser && !isValidUser(newUser))
+      return;
+    setUserState(newUser);
+    saveUserToStorage(newUser);
+  }, [isValidUser, saveUserToStorage]);
+  const fetchUserFromUrl = useCallback(async () => {
+    if (!userUrl)
+      return;
+    setIsLoading(true);
+    try {
+      const response = await fetch(userUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch user: ${response.status} ${response.statusText}`);
+      }
+      const userData = await response.json();
+      if (userData.sso?.expires && typeof userData.sso.expires === "string") {
+        userData.sso.expires = new Date(userData.sso.expires);
+      }
+      if (isValidUser(userData)) {
+        setUserState(userData);
+        saveUserToStorage(userData);
+      }
+    } catch (error) {
+      console.error("Error fetching user from URL:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [userUrl, isValidUser, saveUserToStorage]);
   useEffect(() => {
-    const fetchUser = async () => {
-      try {
-        const response = await fetch(resolvedApiUrl);
-        setStatus(response.status);
-        if (response.ok) {
-          const userData = await response.json();
-          setUser(userData);
-        } else {
-          setUser(undefined);
+    const storedUser = loadUserFromStorage();
+    if (storedUser) {
+      setUserState(storedUser);
+      setIsLoading(false);
+    } else if (userUrl) {
+      fetchUserFromUrl();
+    } else {
+      setIsLoading(false);
+    }
+  }, [loadUserFromStorage, userUrl, fetchUserFromUrl]);
+  useEffect(() => {
+    console.log(disableListener, storage, actualStorageKey);
+    if (disableListener || storage === "memory")
+      return;
+    console.log("set up listener");
+    const handleStorageChange = (event) => {
+      console.log("lsitened", actualStorageKey);
+      if (event.key !== actualStorageKey)
+        return;
+      if (event.newValue === null) {
+        setUserState(null);
+      } else {
+        try {
+          const parsedUser = JSON.parse(event.newValue);
+          if (parsedUser.sso?.expires) {
+            parsedUser.sso.expires = new Date(parsedUser.sso.expires);
+          }
+          if (isValidUser(parsedUser)) {
+            setUserState(parsedUser);
+          }
+        } catch (error) {
+          console.error("Error parsing user from storage event:", error);
         }
-      } catch (error) {
-        console.error("Error fetching user:", error);
-        setUser(undefined);
       }
-      setIsLoading(false);
     };
-    fetchUser();
-  }, [resolvedApiUrl]);
-  return { isLoading, user, status };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [disableListener, storage, actualStorageKey, isValidUser]);
+  const contextValue = {
+    user,
+    setUser,
+    isLoading
+  };
+  return /* @__PURE__ */ jsxDEV4(SSOContext.Provider, {
+    value: contextValue,
+    children
+  }, undefined, false, undefined, this);
+}
+function useUser() {
+  const context = useContext(SSOContext);
+  if (context === undefined) {
+    throw new Error("useUser must be used within a SSOProvider");
+  }
+  return context;
 }
 
 // src/index.ts
@@ -616,5 +760,9 @@ export {
   getUser,
   getRequiredUser,
   enterpriseStandard,
-  callback
+  callback,
+  SignedOut,
+  SignedIn,
+  SignInLoading,
+  SSOProvider
 };

package/dist/server.d.ts

@@ -1,5 +1,5 @@
-import { EnterpriseStandard, EnterpriseUser } from ".";
-export declare function getUser(request: Request, es?: EnterpriseStandard): Promise<EnterpriseUser | undefined>;
-export declare function getRequiredUser(request: Request, es?: EnterpriseStandard): Promise<EnterpriseUser>;
+import type { EnterpriseStandard } from '.';
+export declare function getUser(request: Request, es?: EnterpriseStandard): Promise<import("./enterprise-user").EnterpriseUser | undefined>;
+export declare function getRequiredUser(request: Request, es?: EnterpriseStandard): Promise<import("./enterprise-user").EnterpriseUser>;
 export declare function initiateLogin(landingPage: string, errorPage?: string, es?: EnterpriseStandard): Promise<Response>;
 export declare function callback(request: Request, es?: EnterpriseStandard): Promise<Response>;

package/dist/ui/sign-in-loading.d.ts

@@ -0,0 +1,2 @@
+import type { PropsWithChildren } from 'react';
+export declare function SignInLoading({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/ui/signed-in.d.ts

@@ -1,6 +1,2 @@
-import { PropsWithChildren } from "react";
-import { EnterpriseStandard } from "..";
-export type Props = {
-    es?: EnterpriseStandard;
-} & PropsWithChildren;
-export declare function SignedIn({ es, children }: Props): import("react/jsx-runtime").JSX.Element;
+import type { PropsWithChildren } from 'react';
+export declare function SignedIn({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/ui/signed-out.d.ts

@@ -0,0 +1,2 @@
+import type { PropsWithChildren } from 'react';
+export declare function SignedOut({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/ui/sso-provider.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { EnterpriseUser } from '../enterprise-user';
+type StorageType = 'local' | 'session' | 'memory';
+interface SSOProviderProps {
+    tenantId?: string;
+    storage?: StorageType;
+    storageKey?: string;
+    userUrl?: string;
+    disableListener?: boolean;
+    children: ReactNode;
+}
+interface SSOContextValue {
+    user: EnterpriseUser | null;
+    setUser: (user: EnterpriseUser | null) => void;
+    isLoading: boolean;
+}
+export declare function SSOProvider({ tenantId, storage, storageKey, userUrl, disableListener, children, }: SSOProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useUser(): SSOContextValue;
+export {};

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { type EnterpriseStandard } from ".";
+import type { EnterpriseStandard } from '.';
 export declare function must<T>(value: T | undefined | null, message?: string): T;
 export declare function setDefaultInstance(es: EnterpriseStandard): void;
 export declare function getDefaultInstance(): EnterpriseStandard | undefined;

package/dist/vault.d.ts

@@ -4,7 +4,6 @@ type Secret<T> = {
 };
 type MetaData = {
     created_time: string;
-    custom_metadata: any;
     deletion_time: string;
     destroyed: boolean;
     version: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enterprisestandard/react",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Enterprise Standard React Components",
   "private": false,
   "main": "dist/index.js",

package/dist/useUser.d.ts

@@ -1,8 +0,0 @@
-import { EnterpriseUser } from '.';
-type UseUser = {
-    isLoading: boolean;
-    user?: EnterpriseUser;
-    status?: number;
-};
-export declare function useUser(apiUrl?: string): UseUser;
-export {};