@gofreego/tsutils 0.1.13 → 0.1.14

package/dist/index.js

@@ -1281,169 +1281,169 @@ function formatDate(date, options = {
   const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
   return new Intl.DateTimeFormat("en-US", options).format(dateObj);
 }
-function getCookie(name) {
-  if (typeof document === "undefined") return null;
-  const value = `; ${document.cookie}`;
-  const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) return parts.pop()?.split(";").shift() || null;
-  return null;
-}
-function decodeJWT(token) {
-  try {
-    const base64Url = token.split(".")[1];
-    if (!base64Url) return null;
-    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-    const jsonPayload = decodeURIComponent(
-      window.atob(base64).split("").map(function(c) {
-        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-      }).join("")
-    );
-    return JSON.parse(jsonPayload);
-  } catch (e) {
-    return null;
+
+// src/auth/sessionManager.ts
+var SESSION_KEY = "session_details";
+var SessionManager = class _SessionManager {
+  constructor(client, key = SESSION_KEY) {
+    this.cache = null;
+    this.client = client;
+    this.key = key;
   }
-}
-var AuthContext = react.createContext({
-  isAuthenticated: false,
-  isLoading: true
-});
-var AuthProvider = ({
-  cookieName = "authorization",
-  redirectUrl,
-  children,
-  onAuthFail,
-  onAuthSuccess,
-  loadingElement = null
-}) => {
-  const [authState, setAuthState] = react.useState({
-    isAuthenticated: false,
-    isLoading: true
-    // starts loading until cookie check completes
-  });
-  const [authFailed, setAuthFailed] = react.useState(false);
-  react.useEffect(() => {
-    const verifyAuth = () => {
-      const token = getCookie(cookieName);
-      if (!token) {
-        handleFail();
-        return;
-      }
-      const decoded = decodeJWT(token);
-      if (!decoded) {
-        handleFail();
-        return;
-      }
-      if (decoded.exp) {
-        const expirationDate = new Date(decoded.exp * 1e3);
-        if (expirationDate < /* @__PURE__ */ new Date()) {
-          handleFail();
-          return;
-        }
-      }
-      setAuthState({
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (onAuthSuccess) {
-        onAuthSuccess();
-      }
-    };
-    verifyAuth();
-  }, [cookieName]);
-  const handleFail = () => {
-    setAuthState({
-      isAuthenticated: false,
-      isLoading: false
-    });
-    setAuthFailed(true);
-    if (onAuthFail) {
-      onAuthFail();
-    } else if (redirectUrl && typeof window !== "undefined") {
-      window.location.href = redirectUrl;
+  static getInstance(client) {
+    if (!_SessionManager.instance) {
+      _SessionManager.instance = new _SessionManager(client);
     }
-  };
-  if (authState.isLoading || authFailed && !onAuthFail) {
-    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingElement });
+    return _SessionManager.instance;
   }
-  if (authFailed && onAuthFail) {
-    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  save(session) {
+    this.cache = session;
+    LocalStorage.setItem(this.key, session);
+    this.setAuthToken(session.accessToken);
+  }
+  patch(updates) {
+    const current = this.get();
+    if (!current) return;
+    const updated = { ...current, ...updates };
+    this.cache = updated;
+    LocalStorage.setItem(this.key, updated);
+    if (updates.accessToken) {
+      this.setAuthToken(updates.accessToken);
+    }
+  }
+  clear() {
+    this.cache = null;
+    LocalStorage.removeItem(this.key);
+    this.clearAuthToken();
+  }
+  get() {
+    if (this.cache !== null) return this.cache;
+    this.cache = LocalStorage.getItem(this.key);
+    return this.cache;
+  }
+  getAccessToken() {
+    return this.get()?.accessToken || void 0;
+  }
+  getRefreshToken() {
+    return this.get()?.refreshToken || void 0;
+  }
+  getSessionId() {
+    return this.get()?.sessionId || void 0;
+  }
+  isAuthenticated() {
+    const session = this.get();
+    if (!session?.accessToken) return false;
+    return Number(session.expiresAt) > Date.now() / 1e3;
+  }
+  initialize() {
+    const session = this.get();
+    if (session?.accessToken && Number(session.expiresAt) > Date.now() / 1e3) {
+      this.setAuthToken(session.accessToken);
+    } else {
+      this.clear();
+    }
+  }
+  setAuthToken(token) {
+    this.client.setDefaultHeader("Authorization", `Bearer ${token}`);
+  }
+  clearAuthToken() {
+    this.client.removeDefaultHeader("Authorization");
   }
-  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value: authState, children });
-};
-var useAuth = () => {
-  return react.useContext(AuthContext);
 };
 
-// src/auth/PermissionManager.ts
-var PERMISSIONS_STORAGE_KEY = "auth_permissions";
-var PermissionManager = class {
-  /**
-   * Saves an array of permission strings to local storage.
-   * @param permissions Array of permission strings.
-   */
-  static setPermissions(permissions) {
-    this.cachedPermissions = new Set(permissions);
-    if (typeof window === "undefined") return;
-    try {
-      localStorage.setItem(PERMISSIONS_STORAGE_KEY, JSON.stringify(permissions));
-    } catch (error) {
-      console.error("Failed to save permissions to localStorage", error);
+// src/auth/AuthService.ts
+var BASE_URL = "/openauth/v1";
+var AuthService = class _AuthService {
+  constructor(client) {
+    this.client = client;
+    this.sessionManager = SessionManager.getInstance(client);
+  }
+  static getInstance(client) {
+    if (!_AuthService.instance) {
+      _AuthService.instance = new _AuthService(client);
     }
+    return _AuthService.instance;
   }
-  /**
-   * Retrieves the currently stored permissions from local storage or memory cache.
-   * @returns Array of permission strings, or an empty array if none exist.
-   */
-  static getPermissions() {
-    if (this.cachedPermissions !== null) {
-      return Array.from(this.cachedPermissions);
+  async signIn(request) {
+    const response = await this.client.post(
+      `${BASE_URL}/auth/signin`,
+      request
+    );
+    if (response.data.accessToken) {
+      this.sessionManager.save(response.data);
+    }
+    return response.data;
+  }
+  async refreshToken(request) {
+    const refreshToken = this.sessionManager.getRefreshToken();
+    if (!refreshToken) {
+      throw new Error("No refresh token available");
+    }
+    const response = await this.client.post(
+      `${BASE_URL}/auth/refresh`,
+      { refreshToken, ...request }
+    );
+    if (response.data.accessToken) {
+      this.sessionManager.patch({
+        accessToken: response.data.accessToken,
+        refreshToken: response.data.refreshToken
+      });
     }
-    if (typeof window === "undefined") return [];
+    return response.data;
+  }
+  async logout(request) {
     try {
-      const stored = localStorage.getItem(PERMISSIONS_STORAGE_KEY);
-      if (!stored) {
-        this.cachedPermissions = /* @__PURE__ */ new Set();
-        return [];
-      }
-      const parsed = JSON.parse(stored);
-      const permissionsArray = Array.isArray(parsed) ? parsed : [];
-      this.cachedPermissions = new Set(permissionsArray);
-      return permissionsArray;
-    } catch (error) {
-      console.error("Failed to parse permissions from localStorage", error);
-      this.cachedPermissions = /* @__PURE__ */ new Set();
-      return [];
+      request.sessionId = this.sessionManager.getSessionId();
+      const response = await this.client.post(
+        `${BASE_URL}/auth/logout`,
+        request || {}
+      );
+      return response.data;
+    } finally {
+      this.sessionManager.clear();
     }
   }
-  /**
-   * Clears all stored permissions from memory and local storage.
-   */
-  static clearPermissions() {
-    this.cachedPermissions = null;
-    if (typeof window === "undefined") return;
-    localStorage.removeItem(PERMISSIONS_STORAGE_KEY);
+  async generateLoginToken(request) {
+    const response = await this.client.put(
+      `${BASE_URL}/auth/login-token`,
+      request ?? {}
+    );
+    return response.data;
   }
-  /**
-   * Checks whether the given permission string exists in the currently stored permissions.
-   * @param permission The permission string to check for.
-   * @returns True if the permission exists, false otherwise.
-   */
-  static hasPermission(permission) {
-    if (this.cachedPermissions === null) {
-      this.getPermissions();
+  async signInWithLoginToken(request) {
+    const response = await this.client.post(
+      `${BASE_URL}/auth/signin-with-token`,
+      request
+    );
+    if (response.data.accessToken) {
+      this.sessionManager.save(response.data);
     }
-    return this.cachedPermissions.has(permission);
+    return response.data;
+  }
+  isAuthenticated() {
+    return this.sessionManager.isAuthenticated();
+  }
+  getAccessToken() {
+    return this.sessionManager.getAccessToken();
+  }
+  getSessionDetails() {
+    return this.sessionManager.get();
+  }
+  getSessionId() {
+    return this.sessionManager.getSessionId();
+  }
+  initializeAuth() {
+    this.sessionManager.initialize();
   }
 };
-PermissionManager.cachedPermissions = null;
 
-exports.AuthProvider = AuthProvider;
+exports.AuthService = AuthService;
 exports.ConfirmDialog = ConfirmDialog;
 exports.HttpClient = HttpClient;
 exports.LocalStorage = LocalStorage;
 exports.NotificationProvider = NotificationProvider;
-exports.PermissionManager = PermissionManager;
 exports.ReadmeViewer = ReadmeViewer_default;
+exports.SessionManager = SessionManager;
 exports.SidebarLayout = SidebarLayout;
 exports.ThemeProvider = ThemeProvider;
 exports.ThemeToggle = ThemeToggle;
@@ -1463,7 +1463,6 @@ exports.spacing = spacing;
 exports.throttle = throttle;
 exports.tokens = tokens_exports;
 exports.transition = transition;
-exports.useAuth = useAuth;
 exports.useNotification = useNotification;
 exports.useTheme = useTheme;
 exports.zIndex = zIndex;