react-token-manager 1.0.5 → 1.0.6

package/README.md

@@ -27,16 +27,18 @@ configureTokenManager({
 import { useTokenManager } from 'react-token-manager'
 
 export default function Dashboard() {
-  const { 
-    setTokens, 
-    getTokens, 
-    removeTokens, 
-    clearAllTokens, 
-    decodeToken, 
-    isExpired 
+  const {
+    setTokens,
+    getTokens,
+    getAllTokens,
+    getSingleToken,
+    removeTokens,
+    clearTokens,
+    decodeToken,
+    isExpired,
   } = useTokenManager()
 
-  // Set multiple tokens at once
+  // Set multiple tokens
   setTokens({
     access_token: 'abc123',
     refresh_token: 'xyz789',
@@ -45,27 +47,26 @@ export default function Dashboard() {
   // Get multiple tokens
   const tokens = getTokens(['access_token', 'refresh_token'])
   console.log(tokens.access_token) // 'abc123'
-  console.log(tokens.refresh_token) // 'xyz789'
+
+  // Get all tracked tokens
+  const allTokens = getAllTokens()
+  console.log(allTokens)
+
+  // Get a single token by key
+  const accessToken = getSingleToken('access_token')
+  console.log(accessToken)
 
   // Decode a token
-  const payload = decodeToken(tokens.access_token!)
+  const payload = decodeToken(accessToken!)
 
   // Check if a token is expired
-  console.log(isExpired(tokens.access_token!))
+  console.log(isExpired(accessToken!))
 
   // Remove multiple tokens
   removeTokens(['access_token', 'refresh_token'])
 
   // Clear all tracked tokens
-  clearAllTokens()
-
-  return (
-    <div>
-      <p>Access Token: {tokens.access_token}</p>
-      <p>Refresh Token: {tokens.refresh_token}</p>
-      <p>Decoded Payload: {JSON.stringify(payload)}</p>
-    </div>
-  )
+  clearTokens()
 }
 ```
 
@@ -86,18 +87,26 @@ manager.set({
 
 // Get multiple tokens
 const tokens = manager.get(['access_token', 'refresh_token'])
-console.log(tokens.access_token) // 'abc123'
+console.log(tokens.access_token)
 
-// Remove multiple tokens
-manager.remove(['access_token', 'refresh_token'])
+// Get a single token
+const access = manager.getOne('access_token')
+
+// Get all tracked tokens
+const allTokens = manager.getAll()
+console.log(allTokens)
+
+// Decode a token
+console.log(manager.decode(access!))
 
-// Clear all tracked tokens
-manager.clearAll()
+// Check if token is expired
+console.log(manager.isExpired(access!))
 
-// Decode and check expiration
-console.log(manager.decode(tokens.access_token!))
-console.log(manager.isExpired(tokens.access_token!))
+// Remove multiple tokens
+manager.remove(['access_token', 'refresh_token'])
 
+// Clear all tokens
+manager.clear()
 ```
 
 ## API Reference
@@ -115,7 +124,11 @@ useTokenManager(options?: TokenManagerOptions)
 Returns:
   setTokens(tokens: Record<string, string>)       // Set multiple tokens
 
-  getTokens(keys: string | string[])             // Get multiple tokens
+  getTokens(keys: string | string[])              // Get multiple tokens
+
+  getAllTokens()	                                // Get all tracked tokens
+
+  getSingleToken(key: string)	                    //Get a single token by key
 
   removeTokens(keys: string | string[])          // Remove multiple tokens
 
@@ -129,6 +142,10 @@ TokenManager Class Methods
 
   get(keys: string | string[])                   // Retrieve multiple tokens
 
+  getOne(key: string)	                           // Retrieve a single token
+
+  getAll()	                                      // Get all tracked tokens
+
   remove(keys: string | string[])                // Delete multiple tokens
 
   decode<T = unknown>(token: string)             // Decode a single token
@@ -163,11 +180,13 @@ configureTokenManager({ storage: 'cookie' })
 Checking Expiry Before API Call
 
 ```bash
-const { getTokens, isExpired } = useTokenManager()
-const { access_token } = getTokens(['access_token'])
+const { getSingleToken, isExpired } = useTokenManager()
+const accessToken = getSingleToken('access_token')
 
-if (!isExpired(access_token!)) {
-  callApi(access_token)
+if (!isExpired(accessToken!)) {
+  callApi(accessToken)
+} else {
+  refreshToken()
 }
 ```
 

package/dist/index.d.mts

@@ -9,8 +9,12 @@ declare class TokenManager {
     constructor(options?: TokenManagerOptions);
     /** Set multiple tokens at once */
     set(tokens: Record<string, string>): void;
-    /** Get token(s) */
+    /** Get token(s) by key(s) */
     get(keys: string | string[]): Record<string, string | null>;
+    /** Get a single token by key */
+    getOne(key: string): string | null;
+    /** Get all tracked tokens */
+    getAll(): Record<string, string | null>;
     /** Remove specific tokens */
     remove(keys: string | string[]): void;
     /** Clear all tracked auth tokens */
@@ -26,8 +30,12 @@ declare class TokenManager {
 declare const useTokenManager: () => {
     /** Set multiple tokens */
     setTokens: (tokens: Record<string, string>) => void;
+    /** Get all tokens by keys */
+    getAllTokens: () => Record<string, string | null>;
     /** Get multiple tokens by keys */
     getTokens: (keys: string | string[]) => Record<string, string | null>;
+    /** Get a single token by key */
+    getSingleToken: (key: string) => string | null;
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => void;
     clearTokens: () => void;

package/dist/index.d.ts

@@ -9,8 +9,12 @@ declare class TokenManager {
     constructor(options?: TokenManagerOptions);
     /** Set multiple tokens at once */
     set(tokens: Record<string, string>): void;
-    /** Get token(s) */
+    /** Get token(s) by key(s) */
     get(keys: string | string[]): Record<string, string | null>;
+    /** Get a single token by key */
+    getOne(key: string): string | null;
+    /** Get all tracked tokens */
+    getAll(): Record<string, string | null>;
     /** Remove specific tokens */
     remove(keys: string | string[]): void;
     /** Clear all tracked auth tokens */
@@ -26,8 +30,12 @@ declare class TokenManager {
 declare const useTokenManager: () => {
     /** Set multiple tokens */
     setTokens: (tokens: Record<string, string>) => void;
+    /** Get all tokens by keys */
+    getAllTokens: () => Record<string, string | null>;
     /** Get multiple tokens by keys */
     getTokens: (keys: string | string[]) => Record<string, string | null>;
+    /** Get a single token by key */
+    getSingleToken: (key: string) => string | null;
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => void;
     clearTokens: () => void;

package/dist/index.js

@@ -60,21 +60,27 @@ var TokenManager = class {
       else document.cookie = `${key}=${value}; path=/`;
     });
   }
-  /** Get token(s) */
+  /** Get token(s) by key(s) */
   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;
+      result[key] = this.getOne(key);
+    });
+    return result;
+  }
+  /** Get a single token by key */
+  getOne(key) {
+    if (this.storage === "localStorage") return localStorage.getItem(key);
+    if (this.storage === "sessionStorage") return sessionStorage.getItem(key);
+    const match = document.cookie.match(new RegExp("(^| )" + key + "=([^;]+)"));
+    return match ? match[2] : null;
+  }
+  /** Get all tracked tokens */
+  getAll() {
+    const result = {};
+    this.trackedKeys.forEach((key) => {
+      result[key] = this.getOne(key);
     });
     return result;
   }
@@ -114,8 +120,8 @@ var TokenManager = class {
   isExpired(token) {
     let tokenToCheck = token;
     if (!tokenToCheck) {
-      const stored = this.get("access_token");
-      tokenToCheck = stored["access_token"] || void 0;
+      const stored = this.getOne("access_token");
+      tokenToCheck = stored || void 0;
     }
     if (!tokenToCheck) return true;
     const decoded = this.decode(tokenToCheck);
@@ -131,8 +137,12 @@ var useTokenManager = () => {
   return {
     /** Set multiple tokens */
     setTokens: (tokens) => manager.set(tokens),
+    /** Get all tokens by keys */
+    getAllTokens: () => manager.getAll(),
     /** Get multiple tokens by keys */
     getTokens: (keys) => manager.get(keys),
+    /** Get a single token by key */
+    getSingleToken: (key) => manager.getOne(key),
     /** Remove multiple tokens by keys */
     removeTokens: (keys) => manager.remove(keys),
     clearTokens: () => manager.clear(),

package/dist/index.mjs

@@ -22,21 +22,27 @@ var TokenManager = class {
       else document.cookie = `${key}=${value}; path=/`;
     });
   }
-  /** Get token(s) */
+  /** Get token(s) by key(s) */
   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;
+      result[key] = this.getOne(key);
+    });
+    return result;
+  }
+  /** Get a single token by key */
+  getOne(key) {
+    if (this.storage === "localStorage") return localStorage.getItem(key);
+    if (this.storage === "sessionStorage") return sessionStorage.getItem(key);
+    const match = document.cookie.match(new RegExp("(^| )" + key + "=([^;]+)"));
+    return match ? match[2] : null;
+  }
+  /** Get all tracked tokens */
+  getAll() {
+    const result = {};
+    this.trackedKeys.forEach((key) => {
+      result[key] = this.getOne(key);
     });
     return result;
   }
@@ -76,8 +82,8 @@ var TokenManager = class {
   isExpired(token) {
     let tokenToCheck = token;
     if (!tokenToCheck) {
-      const stored = this.get("access_token");
-      tokenToCheck = stored["access_token"] || void 0;
+      const stored = this.getOne("access_token");
+      tokenToCheck = stored || void 0;
     }
     if (!tokenToCheck) return true;
     const decoded = this.decode(tokenToCheck);
@@ -93,8 +99,12 @@ var useTokenManager = () => {
   return {
     /** Set multiple tokens */
     setTokens: (tokens) => manager.set(tokens),
+    /** Get all tokens by keys */
+    getAllTokens: () => manager.getAll(),
     /** Get multiple tokens by keys */
     getTokens: (keys) => manager.get(keys),
+    /** Get a single token by key */
+    getSingleToken: (key) => manager.getOne(key),
     /** Remove multiple tokens by keys */
     removeTokens: (keys) => manager.remove(keys),
     clearTokens: () => manager.clear(),

package/package.json

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

package/src/core.ts

@@ -31,36 +31,41 @@ export class TokenManager {
   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 token(s) */
+  /** Get token(s) by key(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
+      result[key] = this.getOne(key)
     })
 
     return result
   }
 
+  /** Get a single token by key */
+  getOne(key: string): string | null {
+    if (this.storage === 'localStorage') return localStorage.getItem(key)
+    if (this.storage === 'sessionStorage') return sessionStorage.getItem(key)
+    const match = document.cookie.match(new RegExp('(^| )' + key + '=([^;]+)'))
+    return match ? match[2] : null
+  }
+
+  /** Get all tracked tokens */
+  getAll(): Record<string, string | null> {
+    const result: Record<string, string | null> = {}
+    this.trackedKeys.forEach((key) => {
+      result[key] = this.getOne(key)
+    })
+    return result
+  }
+
   /** Remove specific tokens */
   remove(keys: string | string[]) {
     const keyArray = Array.isArray(keys) ? keys : [keys]
@@ -103,10 +108,9 @@ export class TokenManager {
   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
+      const stored = this.getOne('access_token')
+      tokenToCheck = stored || undefined
     }
 
     if (!tokenToCheck) return true
@@ -117,5 +121,4 @@ export class TokenManager {
 
     return Date.now() >= decoded.exp * 1000
   }
-
 }

package/src/hook.ts

@@ -8,11 +8,18 @@ export const useTokenManager = () => {
     /** Set multiple tokens */
     setTokens: (tokens: Record<string, string>) => manager.set(tokens),
 
+    /** Get all tokens by keys */
+    getAllTokens: () => manager.getAll(),
+
     /** Get multiple tokens by keys */
     getTokens: (keys: string | string[]) => manager.get(keys),
 
+    /** Get a single token by key */
+    getSingleToken: (key: string) => manager.getOne(key),
+
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => manager.remove(keys),
+    
 
     clearTokens: () => manager.clear(),