nextauthz 1.3.9 → 1.3.11

package/dist/index.js

@@ -28,8 +28,186 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/AuthProvider.tsx
+var import_react2 = require("react");
+
+// node_modules/jwt-decode/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  InvalidTokenError: () => InvalidTokenError,
+  jwtDecode: () => jwtDecode
+});
+var InvalidTokenError = class extends Error {
+};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+
+// node_modules/react-token-manager/dist/index.mjs
 var import_react = require("react");
-var import_react_token_manager = require("react-token-manager");
+var jwtDecode2 = void 0 || esm_exports;
+var globalOptions = {
+  storage: "localStorage"
+};
+var configureTokenManager = (options) => {
+  globalOptions = { ...globalOptions, ...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 token(s) by key(s) */
+  get(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    const result = {};
+    keyArray.forEach((key) => {
+      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;
+  }
+  /** 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=/`;
+      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 token */
+  decode(token) {
+    if (!token) return null;
+    try {
+      const cleanToken = token.trim().replace(/^"|"$/g, "");
+      return jwtDecode2(cleanToken);
+    } catch (err) {
+      console.error("JWT decode error:", err, token);
+      return null;
+    }
+  }
+  /** Check if a token is expired
+   *  If no token is provided, defaults to checking 'access_token'
+   */
+  isExpired(token) {
+    const tokenToCheck = token != null ? token : this.getOne("access_token");
+    console.log("tokenToCheck:", tokenToCheck);
+    if (!tokenToCheck) return true;
+    const decoded = this.decode(tokenToCheck);
+    console.log("decoded:", decoded);
+    if (!decoded || !decoded.exp) return true;
+    const now = Date.now();
+    const expTime = decoded.exp * 1e3;
+    const isExpired = now >= expTime;
+    console.log("Token expires at:", new Date(expTime), "isExpired:", isExpired);
+    return isExpired;
+  }
+};
+var useTokenManager = () => {
+  const manager = (0, import_react.useMemo)(() => new TokenManager(), []);
+  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(),
+    /** Decode a single token */
+    decodeToken: (token) => manager.decode(token),
+    /** Check expiration of a single token */
+    isExpired: (token) => manager.isExpired(token)
+  };
+};
 
 // store/useGuardStore.ts
 var import_zustand = require("zustand");
@@ -59,14 +237,14 @@ var useAuthStore = (0, import_zustand.create)((set) => ({
 // src/AuthProvider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function createAuthContext(option) {
-  const AuthContext = (0, import_react.createContext)(void 0);
+  const AuthContext = (0, import_react2.createContext)(void 0);
   const AuthProvider = ({ children }) => {
     const storage = option?.storage ?? "cookie";
     const tokenKey = option?.tokenKey ?? "access_token";
-    (0, import_react.useEffect)(() => {
-      (0, import_react_token_manager.configureTokenManager)({ storage });
+    (0, import_react2.useEffect)(() => {
+      configureTokenManager({ storage });
     }, [storage]);
-    const manager = (0, import_react_token_manager.useTokenManager)();
+    const manager = useTokenManager();
     const {
       user,
       role,
@@ -77,7 +255,7 @@ function createAuthContext(option) {
       setAuth,
       setAuthChecked
     } = useAuthStore();
-    (0, import_react.useEffect)(() => {
+    (0, import_react2.useEffect)(() => {
       const storedUser = manager.getSingleToken("user");
       const token = manager.getSingleToken(tokenKey);
       const expired = manager.isExpired(token);
@@ -130,7 +308,7 @@ function createAuthContext(option) {
     );
   };
   const useAuth = () => {
-    const context = (0, import_react.useContext)(AuthContext);
+    const context = (0, import_react2.useContext)(AuthContext);
     if (!context) throw new Error("useAuth must be used within AuthProvider");
     return context;
   };
@@ -142,7 +320,7 @@ function createAuthContext(option) {
 }
 
 // src/AuthGuard.tsx
-var import_react2 = require("react");
+var import_react3 = require("react");
 var import_navigation = require("next/navigation");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var AuthGuard = ({
@@ -152,7 +330,7 @@ var AuthGuard = ({
 }) => {
   const router = (0, import_navigation.useRouter)();
   const { isAuthenticated, isAuthChecked } = useAuthStore();
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!isAuthChecked) return;
     if (!isAuthenticated) {
       router.replace(redirectTo);
@@ -165,7 +343,7 @@ var AuthGuard = ({
 var AuthGuard_default = AuthGuard;
 
 // src/RoleGuard.tsx
-var import_react3 = require("react");
+var import_react4 = require("react");
 var import_navigation2 = require("next/navigation");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var RoleGuard = ({
@@ -176,7 +354,7 @@ var RoleGuard = ({
 }) => {
   const router = (0, import_navigation2.useRouter)();
   const { role, isAuthChecked } = useAuthStore();
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (!isAuthChecked) return;
     if (!role || !allowedRoles.includes(role)) {
       router.replace(redirectTo);

package/dist/index.mjs

@@ -1,8 +1,191 @@
 "use client";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/AuthProvider.tsx
 import { createContext, useContext, useEffect } from "react";
-import { configureTokenManager, useTokenManager } from "react-token-manager";
+
+// node_modules/jwt-decode/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  InvalidTokenError: () => InvalidTokenError,
+  jwtDecode: () => jwtDecode
+});
+var InvalidTokenError = class extends Error {
+};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+
+// node_modules/react-token-manager/dist/index.mjs
+import { useMemo } from "react";
+var jwtDecode2 = void 0 || esm_exports;
+var globalOptions = {
+  storage: "localStorage"
+};
+var configureTokenManager = (options) => {
+  globalOptions = { ...globalOptions, ...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 token(s) by key(s) */
+  get(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    const result = {};
+    keyArray.forEach((key) => {
+      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;
+  }
+  /** 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=/`;
+      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 token */
+  decode(token) {
+    if (!token) return null;
+    try {
+      const cleanToken = token.trim().replace(/^"|"$/g, "");
+      return jwtDecode2(cleanToken);
+    } catch (err) {
+      console.error("JWT decode error:", err, token);
+      return null;
+    }
+  }
+  /** Check if a token is expired
+   *  If no token is provided, defaults to checking 'access_token'
+   */
+  isExpired(token) {
+    const tokenToCheck = token != null ? token : this.getOne("access_token");
+    console.log("tokenToCheck:", tokenToCheck);
+    if (!tokenToCheck) return true;
+    const decoded = this.decode(tokenToCheck);
+    console.log("decoded:", decoded);
+    if (!decoded || !decoded.exp) return true;
+    const now = Date.now();
+    const expTime = decoded.exp * 1e3;
+    const isExpired = now >= expTime;
+    console.log("Token expires at:", new Date(expTime), "isExpired:", isExpired);
+    return isExpired;
+  }
+};
+var useTokenManager = () => {
+  const manager = useMemo(() => new TokenManager(), []);
+  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(),
+    /** Decode a single token */
+    decodeToken: (token) => manager.decode(token),
+    /** Check expiration of a single token */
+    isExpired: (token) => manager.isExpired(token)
+  };
+};
 
 // store/useGuardStore.ts
 import { create } from "zustand";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextauthz",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -23,8 +23,5 @@
     "react": "^18.2.0 || ^19.0.0",
     "react-dom": "^18.2.0 || ^19.0.0",
     "zustand": "^5.0.0"
-  },
-  "dependencies": {
-    "react-token-manager": "^1.1.2"
   }
 }