react-token-manager 1.0.3 → 1.0.5

package/README.md

@@ -27,7 +27,14 @@ configureTokenManager({
 import { useTokenManager } from 'react-token-manager'
 
 export default function Dashboard() {
-  const { setTokens, getTokens, removeTokens, decodeToken, isExpired } = useTokenManager()
+  const { 
+    setTokens, 
+    getTokens, 
+    removeTokens, 
+    clearAllTokens, 
+    decodeToken, 
+    isExpired 
+  } = useTokenManager()
 
   // Set multiple tokens at once
   setTokens({
@@ -49,6 +56,9 @@ export default function Dashboard() {
   // Remove multiple tokens
   removeTokens(['access_token', 'refresh_token'])
 
+  // Clear all tracked tokens
+  clearAllTokens()
+
   return (
     <div>
       <p>Access Token: {tokens.access_token}</p>
@@ -77,20 +87,21 @@ manager.set({
 // Get multiple tokens
 const tokens = manager.get(['access_token', 'refresh_token'])
 console.log(tokens.access_token) // 'abc123'
-console.log(tokens.refresh_token) // 'xyz789'
 
 // Remove multiple tokens
 manager.remove(['access_token', 'refresh_token'])
 
-// Decode and check expiration of a single 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!))
+
 ```
 
 ## API Reference
 
-configureTokenManager(options: TokenManagerOptions)
-
 Set global options.
 
 ```bash

package/dist/index.d.mts

@@ -5,17 +5,22 @@ interface TokenManagerOptions {
 declare const configureTokenManager: (options: TokenManagerOptions) => void;
 declare class TokenManager {
     private storage;
+    private trackedKeys;
     constructor(options?: TokenManagerOptions);
     /** 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 token(s) */
     get(keys: string | string[]): Record<string, string | null>;
-    /** Remove multiple tokens by keys */
+    /** Remove specific tokens */
     remove(keys: string | string[]): void;
-    /** Decode a single token by key */
+    /** Clear all tracked auth tokens */
+    clear(): void;
+    /** Decode token */
     decode<T = unknown>(token: string): T | null;
-    /** Check if a token is expired */
-    isExpired(token: string): boolean;
+    /** Check if a token is expired
+     *  If no token is provided, defaults to checking 'access_token'
+     */
+    isExpired(token?: string): boolean;
 }
 
 declare const useTokenManager: () => {
@@ -25,6 +30,7 @@ declare const useTokenManager: () => {
     getTokens: (keys: string | string[]) => Record<string, string | null>;
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => void;
+    clearTokens: () => void;
     /** Decode a single token */
     decodeToken: <T = unknown>(token: string) => T | null;
     /** Check expiration of a single token */

package/dist/index.d.ts

@@ -5,17 +5,22 @@ interface TokenManagerOptions {
 declare const configureTokenManager: (options: TokenManagerOptions) => void;
 declare class TokenManager {
     private storage;
+    private trackedKeys;
     constructor(options?: TokenManagerOptions);
     /** 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 token(s) */
     get(keys: string | string[]): Record<string, string | null>;
-    /** Remove multiple tokens by keys */
+    /** Remove specific tokens */
     remove(keys: string | string[]): void;
-    /** Decode a single token by key */
+    /** Clear all tracked auth tokens */
+    clear(): void;
+    /** Decode token */
     decode<T = unknown>(token: string): T | null;
-    /** Check if a token is expired */
-    isExpired(token: string): boolean;
+    /** Check if a token is expired
+     *  If no token is provided, defaults to checking 'access_token'
+     */
+    isExpired(token?: string): boolean;
 }
 
 declare const useTokenManager: () => {
@@ -25,6 +30,7 @@ declare const useTokenManager: () => {
     getTokens: (keys: string | string[]) => Record<string, string | null>;
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => void;
+    clearTokens: () => void;
     /** Decode a single token */
     decodeToken: <T = unknown>(token: string) => T | null;
     /** Check expiration of a single token */

package/dist/index.js

@@ -47,18 +47,20 @@ var configureTokenManager = (options) => {
 };
 var TokenManager = class {
   constructor(options) {
+    this.trackedKeys = /* @__PURE__ */ new Set();
     const opts = options || globalOptions;
     this.storage = opts.storage || "localStorage";
   }
   /** Set multiple tokens at once */
   set(tokens) {
     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 single token by key or all tokens in an array of keys */
+  /** Get token(s) */
   get(keys) {
     const keyArray = Array.isArray(keys) ? keys : [keys];
     const result = {};
@@ -67,23 +69,37 @@ var TokenManager = class {
       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 + "=([^;]+)"));
+        const match = document.cookie.match(
+          new RegExp("(^| )" + key + "=([^;]+)")
+        );
         value = match ? match[2] : null;
       }
       result[key] = value;
     });
     return result;
   }
-  /** Remove multiple tokens by keys */
+  /** Remove specific tokens */
   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=/`;
+      else
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+      this.trackedKeys.delete(key);
     });
   }
-  /** Decode a single token by key */
+  /** Clear all tracked auth tokens */
+  clear() {
+    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 token */
   decode(token) {
     if (!token) return null;
     try {
@@ -92,9 +108,17 @@ var TokenManager = class {
       return null;
     }
   }
-  /** Check if a token is expired */
+  /** Check if a token is expired
+   *  If no token is provided, defaults to checking 'access_token'
+   */
   isExpired(token) {
-    const decoded = this.decode(token);
+    let tokenToCheck = token;
+    if (!tokenToCheck) {
+      const stored = this.get("access_token");
+      tokenToCheck = stored["access_token"] || void 0;
+    }
+    if (!tokenToCheck) return true;
+    const decoded = this.decode(tokenToCheck);
     if (!decoded || !decoded.exp) return true;
     return Date.now() >= decoded.exp * 1e3;
   }
@@ -111,6 +135,7 @@ var useTokenManager = () => {
     getTokens: (keys) => manager.get(keys),
     /** Remove multiple tokens by keys */
     removeTokens: (keys) => manager.remove(keys),
+    clearTokens: () => manager.clear(),
     /** Decode a single token */
     decodeToken: (token) => manager.decode(token),
     /** Check expiration of a single token */

package/dist/index.mjs

@@ -9,18 +9,20 @@ var configureTokenManager = (options) => {
 };
 var TokenManager = class {
   constructor(options) {
+    this.trackedKeys = /* @__PURE__ */ new Set();
     const opts = options || globalOptions;
     this.storage = opts.storage || "localStorage";
   }
   /** Set multiple tokens at once */
   set(tokens) {
     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 single token by key or all tokens in an array of keys */
+  /** Get token(s) */
   get(keys) {
     const keyArray = Array.isArray(keys) ? keys : [keys];
     const result = {};
@@ -29,23 +31,37 @@ var TokenManager = class {
       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 + "=([^;]+)"));
+        const match = document.cookie.match(
+          new RegExp("(^| )" + key + "=([^;]+)")
+        );
         value = match ? match[2] : null;
       }
       result[key] = value;
     });
     return result;
   }
-  /** Remove multiple tokens by keys */
+  /** Remove specific tokens */
   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=/`;
+      else
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+      this.trackedKeys.delete(key);
     });
   }
-  /** Decode a single token by key */
+  /** Clear all tracked auth tokens */
+  clear() {
+    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 token */
   decode(token) {
     if (!token) return null;
     try {
@@ -54,9 +70,17 @@ var TokenManager = class {
       return null;
     }
   }
-  /** Check if a token is expired */
+  /** Check if a token is expired
+   *  If no token is provided, defaults to checking 'access_token'
+   */
   isExpired(token) {
-    const decoded = this.decode(token);
+    let tokenToCheck = token;
+    if (!tokenToCheck) {
+      const stored = this.get("access_token");
+      tokenToCheck = stored["access_token"] || void 0;
+    }
+    if (!tokenToCheck) return true;
+    const decoded = this.decode(tokenToCheck);
     if (!decoded || !decoded.exp) return true;
     return Date.now() >= decoded.exp * 1e3;
   }
@@ -73,6 +97,7 @@ var useTokenManager = () => {
     getTokens: (keys) => manager.get(keys),
     /** Remove multiple tokens by keys */
     removeTokens: (keys) => manager.remove(keys),
+    clearTokens: () => manager.clear(),
     /** Decode a single token */
     decodeToken: (token) => manager.decode(token),
     /** Check expiration of a single token */

package/package.json

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

package/src/core.ts

@@ -20,6 +20,7 @@ export const configureTokenManager = (options: TokenManagerOptions) => {
 
 export class TokenManager {
   private storage: StorageType
+  private trackedKeys: Set<string> = new Set()
 
   constructor(options?: TokenManagerOptions) {
     const opts = options || globalOptions
@@ -29,42 +30,64 @@ export class TokenManager {
   /** 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 single token by key or all tokens in an array of keys */
+  /** 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 + '=([^;]+)'))
+        const match = document.cookie.match(
+          new RegExp('(^| )' + key + '=([^;]+)')
+        )
         value = match ? match[2] : null
       }
+
       result[key] = value
     })
 
     return result
   }
 
-  /** Remove multiple tokens by keys */
+  /** 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=/`
+      else
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`
+
+      this.trackedKeys.delete(key)
+    })
+  }
+
+  /** Clear all tracked auth tokens */
+  clear() {
+    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 a single token by key */
+  /** Decode token */
   decode<T = unknown>(token: string): T | null {
     if (!token) return null
     try {
@@ -74,10 +97,25 @@ export class TokenManager {
     }
   }
 
-  /** Check if a token is expired */
-  isExpired(token: string): boolean {
-    const decoded = this.decode<JwtPayload>(token)
+  /** 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
   }
+
 }

package/src/hook.ts

@@ -14,6 +14,8 @@ export const useTokenManager = () => {
     /** Remove multiple tokens by keys */
     removeTokens: (keys: string | string[]) => manager.remove(keys),
 
+    clearTokens: () => manager.clear(),
+
     /** Decode a single token */
     decodeToken: <T = unknown>(token: string) => manager.decode<T>(token),