react-token-manager 1.0.2 → 1.0.4

package/README.md

@@ -19,7 +19,6 @@ import { configureTokenManager } from 'react-token-manager'
 
 configureTokenManager({
   storage: 'localStorage', // 'localStorage' | 'sessionStorage' | 'cookie'
-  tokenKey: 'access_token', // default: 'access_token'
 })
 ```
 ## Using the Hook useTokenManager
@@ -28,18 +27,43 @@ configureTokenManager({
 import { useTokenManager } from 'react-token-manager'
 
 export default function Dashboard() {
-  const { token, setToken, removeToken, isExpired, decode } = useTokenManager()
-
-  const handleLogin = () => setToken('your.jwt.token.here')
-  const handleLogout = () => removeToken()
+  const { 
+    setTokens, 
+    getTokens, 
+    removeTokens, 
+    clearAllTokens, 
+    decodeToken, 
+    isExpired 
+  } = useTokenManager()
+
+  // Set multiple tokens at once
+  setTokens({
+    access_token: 'abc123',
+    refresh_token: 'xyz789',
+  })
+
+  // Get multiple tokens
+  const tokens = getTokens(['access_token', 'refresh_token'])
+  console.log(tokens.access_token) // 'abc123'
+  console.log(tokens.refresh_token) // 'xyz789'
+
+  // Decode a token
+  const payload = decodeToken(tokens.access_token!)
+
+  // Check if a token is expired
+  console.log(isExpired(tokens.access_token!))
+
+  // Remove multiple tokens
+  removeTokens(['access_token', 'refresh_token'])
+
+  // Clear all tracked tokens
+  clearAllTokens()
 
   return (
     <div>
-      <p>Token: {token}</p>
-      <p>Expired? {isExpired() ? 'Yes' : 'No'}</p>
-      <p>Decoded Payload: {JSON.stringify(decode())}</p>
-      <button onClick={handleLogin}>Login</button>
-      <button onClick={handleLogout}>Logout</button>
+      <p>Access Token: {tokens.access_token}</p>
+      <p>Refresh Token: {tokens.refresh_token}</p>
+      <p>Decoded Payload: {JSON.stringify(payload)}</p>
     </div>
   )
 }
@@ -52,54 +76,65 @@ You can override storage or tokenKey per hook if needed.
 ```bash
 import { TokenManager } from 'react-token-manager'
 
-const manager = new TokenManager({ storage: 'cookie', tokenKey: 'access_token' })
+const manager = new TokenManager({ storage: 'cookie' })
+
+// Set multiple tokens
+manager.set({
+  access_token: 'abc123',
+  refresh_token: 'xyz789',
+})
+
+// Get multiple tokens
+const tokens = manager.get(['access_token', 'refresh_token'])
+console.log(tokens.access_token) // 'abc123'
+
+// Remove multiple tokens
+manager.remove(['access_token', 'refresh_token'])
+
+// Clear all tracked tokens
+manager.clearAll()
+
+// Decode and check expiration
+console.log(manager.decode(tokens.access_token!))
+console.log(manager.isExpired(tokens.access_token!))
 
-manager.set('your.jwt.token')
-console.log(manager.get())
-console.log(manager.decode())  // decoded JWT payload
-console.log(manager.isExpired())
-manager.remove()
 ```
 
 ## API Reference
 
-configureTokenManager(options: TokenManagerOptions)
-
 Set global options.
 
 ```bash
 {
   storage?: 'localStorage' | 'sessionStorage' | 'cookie';
-  tokenKey?: string;
 }
 
+
 useTokenManager(options?: TokenManagerOptions)
 
 Returns:
+  setTokens(tokens: Record<string, string>)       // Set multiple tokens
 
-    token: string | null — current token
+  getTokens(keys: string | string[])             // Get multiple tokens
 
-    setToken(value: string) — set a new token
+  removeTokens(keys: string | string[])          // Remove multiple tokens
 
-    removeToken() — remove the token
+  decodeToken<T = unknown>(token: string)        // Decode a single token
 
-    isExpired(): boolean — check expiration
+  isExpired(token: string)                       // Check if a token is expired
 
-    decode<T>(): T | null — decode JWT payload
 
 TokenManager Class Methods
+  set(tokens: Record<string, string>)            // Store multiple tokens
 
-    set(token: string) — store token
+  get(keys: string | string[])                   // Retrieve multiple tokens
 
-    get(): string | null — retrieve token
+  remove(keys: string | string[])                // Delete multiple tokens
 
-    remove() — delete token
+  decode<T = unknown>(token: string)             // Decode a single token
 
-    decode<T = unknown>(): T | null — decode JWT payload
+  isExpired(token: string)                       // Check if a token is expired
 
-    isExpired(): boolean — check if token is expired
-
-    getValid(): string | null — get token only if valid
 
 ```
 
@@ -108,25 +143,31 @@ TokenManager Class Methods
 Multiple Tokens
 
 ```bash
-const { token: accessToken, setToken: setAccess } = useTokenManager({ tokenKey: 'access_token' })
-const { token: refreshToken, setToken: setRefresh } = useTokenManager({ tokenKey: 'refresh_token' })
+const { setTokens, getTokens } = useTokenManager()
+
+setTokens({
+  access_token: 'abc',
+  refresh_token: 'xyz',
+})
 
-setAccess('abc')
-setRefresh('xyz')
+const tokens = getTokens(['access_token', 'refresh_token'])
+console.log(tokens.access_token) // 'abc'
+console.log(tokens.refresh_token) // 'xyz'
 ```
 
 ##Using Cookies
 ```bash
-configureTokenManager({ storage: 'cookie', tokenKey: 'access_token' })
+configureTokenManager({ storage: 'cookie' })
 ```
 
 Checking Expiry Before API Call
 
 ```bash
-const manager = useTokenManager()
+const { getTokens, isExpired } = useTokenManager()
+const { access_token } = getTokens(['access_token'])
 
-if (!manager.isExpired()) {
-  callApi(manager.token)
+if (!isExpired(access_token!)) {
+  callApi(access_token)
 }
 ```
 

package/dist/index.d.mts

@@ -1,28 +1,34 @@
 type StorageType = 'localStorage' | 'sessionStorage' | 'cookie';
 interface TokenManagerOptions {
     storage?: StorageType;
-    tokenKey?: string;
 }
 declare const configureTokenManager: (options: TokenManagerOptions) => void;
 declare class TokenManager {
     private storage;
-    private tokenKey;
     constructor(options?: TokenManagerOptions);
-    set(token: string): void;
-    get(): string | null;
-    remove(): void;
-    decode<T = unknown>(): T | null;
-    isExpired(): boolean;
-    getValid(): string | null;
+    /** Set multiple tokens at once */
+    set(tokens: Record<string, string>): void;
+    /** Get single token by key or all tokens in an array of keys */
+    get(keys: string | string[]): Record<string, string | null>;
+    /** Remove multiple tokens by keys */
+    remove(keys: string | string[]): void;
+    /** Decode a single token by key */
+    decode<T = unknown>(token: string): T | null;
+    /** Check if a token is expired */
+    isExpired(token: string): boolean;
 }
 
-interface UseTokenManagerReturn {
-    token: string | null;
-    setToken: (value: string) => void;
-    removeToken: () => void;
-    isExpired: () => boolean;
-    decode: <T = unknown>() => T | null;
-}
-declare const useTokenManager: (options?: TokenManagerOptions) => UseTokenManagerReturn;
+declare const useTokenManager: () => {
+    /** Set multiple tokens */
+    setTokens: (tokens: Record<string, string>) => void;
+    /** Get multiple tokens by keys */
+    getTokens: (keys: string | string[]) => Record<string, string | null>;
+    /** Remove multiple tokens by keys */
+    removeTokens: (keys: string | string[]) => void;
+    /** Decode a single token */
+    decodeToken: <T = unknown>(token: string) => T | null;
+    /** Check expiration of a single token */
+    isExpired: (token: string) => boolean;
+};
 
-export { type StorageType, TokenManager, type TokenManagerOptions, type UseTokenManagerReturn, configureTokenManager, useTokenManager };
+export { type StorageType, TokenManager, type TokenManagerOptions, configureTokenManager, useTokenManager };

package/dist/index.d.ts

@@ -1,28 +1,34 @@
 type StorageType = 'localStorage' | 'sessionStorage' | 'cookie';
 interface TokenManagerOptions {
     storage?: StorageType;
-    tokenKey?: string;
 }
 declare const configureTokenManager: (options: TokenManagerOptions) => void;
 declare class TokenManager {
     private storage;
-    private tokenKey;
     constructor(options?: TokenManagerOptions);
-    set(token: string): void;
-    get(): string | null;
-    remove(): void;
-    decode<T = unknown>(): T | null;
-    isExpired(): boolean;
-    getValid(): string | null;
+    /** Set multiple tokens at once */
+    set(tokens: Record<string, string>): void;
+    /** Get single token by key or all tokens in an array of keys */
+    get(keys: string | string[]): Record<string, string | null>;
+    /** Remove multiple tokens by keys */
+    remove(keys: string | string[]): void;
+    /** Decode a single token by key */
+    decode<T = unknown>(token: string): T | null;
+    /** Check if a token is expired */
+    isExpired(token: string): boolean;
 }
 
-interface UseTokenManagerReturn {
-    token: string | null;
-    setToken: (value: string) => void;
-    removeToken: () => void;
-    isExpired: () => boolean;
-    decode: <T = unknown>() => T | null;
-}
-declare const useTokenManager: (options?: TokenManagerOptions) => UseTokenManagerReturn;
+declare const useTokenManager: () => {
+    /** Set multiple tokens */
+    setTokens: (tokens: Record<string, string>) => void;
+    /** Get multiple tokens by keys */
+    getTokens: (keys: string | string[]) => Record<string, string | null>;
+    /** Remove multiple tokens by keys */
+    removeTokens: (keys: string | string[]) => void;
+    /** Decode a single token */
+    decodeToken: <T = unknown>(token: string) => T | null;
+    /** Check expiration of a single token */
+    isExpired: (token: string) => boolean;
+};
 
-export { type StorageType, TokenManager, type TokenManagerOptions, type UseTokenManagerReturn, configureTokenManager, useTokenManager };
+export { type StorageType, TokenManager, type TokenManagerOptions, configureTokenManager, useTokenManager };

package/dist/index.js

@@ -40,8 +40,7 @@ module.exports = __toCommonJS(index_exports);
 var jwtDecodeModule = __toESM(require("jwt-decode"));
 var jwtDecode = jwtDecodeModule.default || jwtDecodeModule;
 var globalOptions = {
-  storage: "localStorage",
-  tokenKey: "access_token"
+  storage: "localStorage"
 };
 var configureTokenManager = (options) => {
   globalOptions = { ...globalOptions, ...options };
@@ -50,26 +49,42 @@ var TokenManager = class {
   constructor(options) {
     const opts = options || globalOptions;
     this.storage = opts.storage || "localStorage";
-    this.tokenKey = opts.tokenKey || "access_token";
   }
-  set(token) {
-    if (this.storage === "localStorage") localStorage.setItem(this.tokenKey, token);
-    else if (this.storage === "sessionStorage") sessionStorage.setItem(this.tokenKey, token);
-    else document.cookie = `${this.tokenKey}=${token}; path=/`;
+  /** Set multiple tokens at once */
+  set(tokens) {
+    Object.entries(tokens).forEach(([key, value]) => {
+      if (this.storage === "localStorage") localStorage.setItem(key, value);
+      else if (this.storage === "sessionStorage") sessionStorage.setItem(key, value);
+      else document.cookie = `${key}=${value}; path=/`;
+    });
   }
-  get() {
-    if (this.storage === "localStorage") return localStorage.getItem(this.tokenKey);
-    if (this.storage === "sessionStorage") return sessionStorage.getItem(this.tokenKey);
-    const match = document.cookie.match(new RegExp("(^| )" + this.tokenKey + "=([^;]+)"));
-    return match ? match[2] : null;
+  /** Get single token by key or all tokens in an array of keys */
+  get(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    const result = {};
+    keyArray.forEach((key) => {
+      let value = null;
+      if (this.storage === "localStorage") value = localStorage.getItem(key);
+      else if (this.storage === "sessionStorage") value = sessionStorage.getItem(key);
+      else {
+        const match = document.cookie.match(new RegExp("(^| )" + key + "=([^;]+)"));
+        value = match ? match[2] : null;
+      }
+      result[key] = value;
+    });
+    return result;
   }
-  remove() {
-    if (this.storage === "localStorage") localStorage.removeItem(this.tokenKey);
-    else if (this.storage === "sessionStorage") sessionStorage.removeItem(this.tokenKey);
-    else document.cookie = `${this.tokenKey}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+  /** Remove multiple tokens by keys */
+  remove(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    keyArray.forEach((key) => {
+      if (this.storage === "localStorage") localStorage.removeItem(key);
+      else if (this.storage === "sessionStorage") sessionStorage.removeItem(key);
+      else document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    });
   }
-  decode() {
-    const token = this.get();
+  /** Decode a single token by key */
+  decode(token) {
     if (!token) return null;
     try {
       return jwtDecode(token);
@@ -77,38 +92,29 @@ var TokenManager = class {
       return null;
     }
   }
-  isExpired() {
-    const decoded = this.decode();
+  /** Check if a token is expired */
+  isExpired(token) {
+    const decoded = this.decode(token);
     if (!decoded || !decoded.exp) return true;
     return Date.now() >= decoded.exp * 1e3;
   }
-  getValid() {
-    return this.isExpired() ? null : this.get();
-  }
 };
 
 // src/hook.ts
 var import_react = require("react");
-var useTokenManager = (options) => {
-  const manager = new TokenManager(options);
-  const [token, setTokenState] = (0, import_react.useState)(null);
-  (0, import_react.useEffect)(() => {
-    setTokenState(manager.getValid());
-  }, []);
-  const setToken = (value) => {
-    manager.set(value);
-    setTokenState(value);
-  };
-  const removeToken = () => {
-    manager.remove();
-    setTokenState(null);
-  };
+var useTokenManager = () => {
+  const manager = (0, import_react.useMemo)(() => new TokenManager(), []);
   return {
-    token,
-    setToken,
-    removeToken,
-    isExpired: () => manager.isExpired(),
-    decode: () => manager.decode()
+    /** Set multiple tokens */
+    setTokens: (tokens) => manager.set(tokens),
+    /** Get multiple tokens by keys */
+    getTokens: (keys) => manager.get(keys),
+    /** Remove multiple tokens by keys */
+    removeTokens: (keys) => manager.remove(keys),
+    /** Decode a single token */
+    decodeToken: (token) => manager.decode(token),
+    /** Check expiration of a single token */
+    isExpired: (token) => manager.isExpired(token)
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.mjs

@@ -2,8 +2,7 @@
 import * as jwtDecodeModule from "jwt-decode";
 var jwtDecode = jwtDecodeModule.default || jwtDecodeModule;
 var globalOptions = {
-  storage: "localStorage",
-  tokenKey: "access_token"
+  storage: "localStorage"
 };
 var configureTokenManager = (options) => {
   globalOptions = { ...globalOptions, ...options };
@@ -12,26 +11,42 @@ var TokenManager = class {
   constructor(options) {
     const opts = options || globalOptions;
     this.storage = opts.storage || "localStorage";
-    this.tokenKey = opts.tokenKey || "access_token";
   }
-  set(token) {
-    if (this.storage === "localStorage") localStorage.setItem(this.tokenKey, token);
-    else if (this.storage === "sessionStorage") sessionStorage.setItem(this.tokenKey, token);
-    else document.cookie = `${this.tokenKey}=${token}; path=/`;
+  /** Set multiple tokens at once */
+  set(tokens) {
+    Object.entries(tokens).forEach(([key, value]) => {
+      if (this.storage === "localStorage") localStorage.setItem(key, value);
+      else if (this.storage === "sessionStorage") sessionStorage.setItem(key, value);
+      else document.cookie = `${key}=${value}; path=/`;
+    });
   }
-  get() {
-    if (this.storage === "localStorage") return localStorage.getItem(this.tokenKey);
-    if (this.storage === "sessionStorage") return sessionStorage.getItem(this.tokenKey);
-    const match = document.cookie.match(new RegExp("(^| )" + this.tokenKey + "=([^;]+)"));
-    return match ? match[2] : null;
+  /** Get single token by key or all tokens in an array of keys */
+  get(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    const result = {};
+    keyArray.forEach((key) => {
+      let value = null;
+      if (this.storage === "localStorage") value = localStorage.getItem(key);
+      else if (this.storage === "sessionStorage") value = sessionStorage.getItem(key);
+      else {
+        const match = document.cookie.match(new RegExp("(^| )" + key + "=([^;]+)"));
+        value = match ? match[2] : null;
+      }
+      result[key] = value;
+    });
+    return result;
   }
-  remove() {
-    if (this.storage === "localStorage") localStorage.removeItem(this.tokenKey);
-    else if (this.storage === "sessionStorage") sessionStorage.removeItem(this.tokenKey);
-    else document.cookie = `${this.tokenKey}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+  /** Remove multiple tokens by keys */
+  remove(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    keyArray.forEach((key) => {
+      if (this.storage === "localStorage") localStorage.removeItem(key);
+      else if (this.storage === "sessionStorage") sessionStorage.removeItem(key);
+      else document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    });
   }
-  decode() {
-    const token = this.get();
+  /** Decode a single token by key */
+  decode(token) {
     if (!token) return null;
     try {
       return jwtDecode(token);
@@ -39,38 +54,29 @@ var TokenManager = class {
       return null;
     }
   }
-  isExpired() {
-    const decoded = this.decode();
+  /** Check if a token is expired */
+  isExpired(token) {
+    const decoded = this.decode(token);
     if (!decoded || !decoded.exp) return true;
     return Date.now() >= decoded.exp * 1e3;
   }
-  getValid() {
-    return this.isExpired() ? null : this.get();
-  }
 };
 
 // src/hook.ts
-import { useEffect, useState } from "react";
-var useTokenManager = (options) => {
-  const manager = new TokenManager(options);
-  const [token, setTokenState] = useState(null);
-  useEffect(() => {
-    setTokenState(manager.getValid());
-  }, []);
-  const setToken = (value) => {
-    manager.set(value);
-    setTokenState(value);
-  };
-  const removeToken = () => {
-    manager.remove();
-    setTokenState(null);
-  };
+import { useMemo } from "react";
+var useTokenManager = () => {
+  const manager = useMemo(() => new TokenManager(), []);
   return {
-    token,
-    setToken,
-    removeToken,
-    isExpired: () => manager.isExpired(),
-    decode: () => manager.decode()
+    /** Set multiple tokens */
+    setTokens: (tokens) => manager.set(tokens),
+    /** Get multiple tokens by keys */
+    getTokens: (keys) => manager.get(keys),
+    /** Remove multiple tokens by keys */
+    removeTokens: (keys) => manager.remove(keys),
+    /** Decode a single token */
+    decodeToken: (token) => manager.decode(token),
+    /** Check expiration of a single token */
+    isExpired: (token) => manager.isExpired(token)
   };
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-token-manager",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A simple React library to manage JWT tokens",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/core.ts

@@ -1,75 +1,121 @@
 import type { JwtPayload } from 'jwt-decode'
 import * as jwtDecodeModule from 'jwt-decode'
 
-// Properly type the callable function
-const jwtDecode: <T = unknown>(token: string) => T = 
+const jwtDecode: <T = unknown>(token: string) => T =
   (jwtDecodeModule as any).default || jwtDecodeModule
 
-
 export type StorageType = 'localStorage' | 'sessionStorage' | 'cookie'
 
 export interface TokenManagerOptions {
   storage?: StorageType
-  tokenKey?: string
 }
 
-// ---------------- Global configuration ----------------
 let globalOptions: TokenManagerOptions = {
   storage: 'localStorage',
-  tokenKey: 'access_token',
 }
 
 export const configureTokenManager = (options: TokenManagerOptions) => {
   globalOptions = { ...globalOptions, ...options }
 }
 
-// ---------------- TokenManager Class ----------------
 export class TokenManager {
   private storage: StorageType
-  private tokenKey: string
+  private trackedKeys: Set<string> = new Set()
 
   constructor(options?: TokenManagerOptions) {
     const opts = options || globalOptions
     this.storage = opts.storage || 'localStorage'
-    this.tokenKey = opts.tokenKey || 'access_token'
   }
 
-  set(token: string) {
-    if (this.storage === 'localStorage') localStorage.setItem(this.tokenKey, token)
-    else if (this.storage === 'sessionStorage') sessionStorage.setItem(this.tokenKey, token)
-    else document.cookie = `${this.tokenKey}=${token}; path=/`
+  /** Set multiple tokens at once */
+  set(tokens: Record<string, string>) {
+    Object.entries(tokens).forEach(([key, value]) => {
+      this.trackedKeys.add(key)
+
+      if (this.storage === 'localStorage') localStorage.setItem(key, value)
+      else if (this.storage === 'sessionStorage') sessionStorage.setItem(key, value)
+      else document.cookie = `${key}=${value}; path=/`
+    })
   }
 
-  get(): string | null {
-    if (this.storage === 'localStorage') return localStorage.getItem(this.tokenKey)
-    if (this.storage === 'sessionStorage') return sessionStorage.getItem(this.tokenKey)
-    const match = document.cookie.match(new RegExp('(^| )' + this.tokenKey + '=([^;]+)'))
-    return match ? match[2] : null
+  /** Get token(s) */
+  get(keys: string | string[]): Record<string, string | null> {
+    const keyArray = Array.isArray(keys) ? keys : [keys]
+    const result: Record<string, string | null> = {}
+
+    keyArray.forEach((key) => {
+      let value: string | null = null
+
+      if (this.storage === 'localStorage') value = localStorage.getItem(key)
+      else if (this.storage === 'sessionStorage') value = sessionStorage.getItem(key)
+      else {
+        const match = document.cookie.match(
+          new RegExp('(^| )' + key + '=([^;]+)')
+        )
+        value = match ? match[2] : null
+      }
+
+      result[key] = value
+    })
+
+    return result
+  }
+
+  /** Remove specific tokens */
+  remove(keys: string | string[]) {
+    const keyArray = Array.isArray(keys) ? keys : [keys]
+
+    keyArray.forEach((key) => {
+      if (this.storage === 'localStorage') localStorage.removeItem(key)
+      else if (this.storage === 'sessionStorage') sessionStorage.removeItem(key)
+      else
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`
+
+      this.trackedKeys.delete(key)
+    })
   }
 
-  remove() {
-    if (this.storage === 'localStorage') localStorage.removeItem(this.tokenKey)
-    else if (this.storage === 'sessionStorage') sessionStorage.removeItem(this.tokenKey)
-    else document.cookie = `${this.tokenKey}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`
+  /** Clear all tracked auth tokens */
+  clearAll() {
+    this.trackedKeys.forEach((key) => {
+      if (this.storage === 'localStorage') localStorage.removeItem(key)
+      else if (this.storage === 'sessionStorage') sessionStorage.removeItem(key)
+      else
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`
+    })
+
+    this.trackedKeys.clear()
   }
 
-  decode<T = unknown>(): T | null {
-    const token = this.get()
+  /** Decode token */
+  decode<T = unknown>(token: string): T | null {
     if (!token) return null
     try {
-      return jwtDecode<T>(token) // Now callable
+      return jwtDecode<T>(token)
     } catch {
       return null
     }
   }
 
-  isExpired(): boolean {
-    const decoded = this.decode<JwtPayload>()
+  /** Check if a token is expired
+   *  If no token is provided, defaults to checking 'access_token'
+   */
+  isExpired(token?: string): boolean {
+    let tokenToCheck = token
+
+    // If no token passed, try to get access_token
+    if (!tokenToCheck) {
+      const stored = this.get('access_token')
+      tokenToCheck = stored['access_token'] || undefined
+    }
+
+    if (!tokenToCheck) return true
+
+    const decoded = this.decode<JwtPayload>(tokenToCheck)
+
     if (!decoded || !decoded.exp) return true
+
     return Date.now() >= decoded.exp * 1000
   }
 
-  getValid(): string | null {
-    return this.isExpired() ? null : this.get()
-  }
 }

package/src/hook.ts

@@ -1,40 +1,25 @@
-import { useEffect, useState } from 'react'
-import { TokenManager, TokenManagerOptions } from './core'
+import { useMemo } from 'react'
+import { TokenManager } from './core'
 
-export interface UseTokenManagerReturn {
-  token: string | null
-  setToken: (value: string) => void
-  removeToken: () => void
-  isExpired: () => boolean
-  decode: <T = unknown>() => T | null
-}
+export const useTokenManager = () => {
+  const manager = useMemo(() => new TokenManager(), [])
 
-export const useTokenManager = (
-  options?: TokenManagerOptions
-): UseTokenManagerReturn => {
-  const manager = new TokenManager(options)
+  return {
+    /** Set multiple tokens */
+    setTokens: (tokens: Record<string, string>) => manager.set(tokens),
 
-  const [token, setTokenState] = useState<string | null>(null)
+    /** Get multiple tokens by keys */
+    getTokens: (keys: string | string[]) => manager.get(keys),
 
-  useEffect(() => {
-    setTokenState(manager.getValid())
-  }, [])
+    /** Remove multiple tokens by keys */
+    removeTokens: (keys: string | string[]) => manager.remove(keys),
 
-  const setToken = (value: string) => {
-    manager.set(value)
-    setTokenState(value)
-  }
+    clearTokens: () => manager.clearAll(),
 
-  const removeToken = () => {
-    manager.remove()
-    setTokenState(null)
-  }
+    /** Decode a single token */
+    decodeToken: <T = unknown>(token: string) => manager.decode<T>(token),
 
-  return {
-    token,
-    setToken,
-    removeToken,
-    isExpired: () => manager.isExpired(),
-    decode: <T = unknown>() => manager.decode<T>(),
+    /** Check expiration of a single token */
+    isExpired: (token: string) => manager.isExpired(token),
   }
 }

package/src/useTokenManager.ts

@@ -1,38 +0,0 @@
-import { useEffect, useState, useMemo } from 'react'
-import { TokenManager } from './core'
-
-export interface UseTokenManagerReturn {
-  token: string | null
-  setToken: (value: string) => void
-  removeToken: () => void
-  isExpired: () => boolean
-  decode: <T = unknown>() => T | null
-}
-
-export const useTokenManager = (): UseTokenManagerReturn => {
-  const manager = useMemo(() => new TokenManager(), [])
-
-  const [token, setTokenState] = useState<string | null>(null)
-
-  useEffect(() => {
-    setTokenState(manager.getValid())
-  }, [manager])
-
-  const setToken = (value: string) => {
-    manager.set(value)
-    setTokenState(value)
-  }
-
-  const removeToken = () => {
-    manager.remove()
-    setTokenState(null)
-  }
-
-  return {
-    token,
-    setToken,
-    removeToken,
-    isExpired: () => manager.isExpired(),
-    decode: <T = unknown>() => manager.decode<T>(),
-  }
-}