@geekmidas/auth 0.0.1

package/dist/__tests__/tokenManager.spec.cjs

@@ -0,0 +1,197 @@
+const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_tokenManager = require('../tokenManager-B60gFnEF.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/__tests__/tokenManager.spec.ts
+(0, vitest.describe)("TokenManager", () => {
+	let tokenManager;
+	let userPayload;
+	(0, vitest.beforeEach)(() => {
+		tokenManager = new require_tokenManager.TokenManager({
+			accessTokenSecret: "test-access-secret",
+			refreshTokenSecret: "test-refresh-secret",
+			accessTokenExpiresIn: "15m",
+			refreshTokenExpiresIn: "7d"
+		});
+		userPayload = {
+			userId: "user123",
+			email: "test@example.com",
+			role: "admin"
+		};
+	});
+	(0, vitest.describe)("token generation and verification workflow", () => {
+		(0, vitest.it)("should generate and verify complete token pair", () => {
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(userPayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			(0, vitest.expect)(accessDecoded.userId).toBe(userPayload.userId);
+			(0, vitest.expect)(accessDecoded.email).toBe(userPayload.email);
+			(0, vitest.expect)(accessDecoded.role).toBe(userPayload.role);
+			(0, vitest.expect)(refreshDecoded.userId).toBe(userPayload.userId);
+			(0, vitest.expect)(refreshDecoded.email).toBe(userPayload.email);
+			(0, vitest.expect)(refreshDecoded.role).toBe(userPayload.role);
+		});
+		(0, vitest.it)("should handle complete token refresh workflow", () => {
+			const { refreshToken } = tokenManager.generateTokenPair(userPayload);
+			const newAccessToken = tokenManager.refreshAccessToken(refreshToken);
+			const newDecoded = tokenManager.verifyAccessToken(newAccessToken);
+			(0, vitest.expect)(newDecoded.userId).toBe(userPayload.userId);
+			(0, vitest.expect)(newDecoded.email).toBe(userPayload.email);
+			(0, vitest.expect)(newDecoded.role).toBe(userPayload.role);
+			(0, vitest.expect)(newDecoded.iat).toBeDefined();
+			(0, vitest.expect)(newDecoded.exp).toBeDefined();
+		});
+		(0, vitest.it)("should maintain payload integrity through refresh cycle", () => {
+			const originalPayload = {
+				userId: "user456",
+				email: "user@example.com",
+				permissions: ["read", "write"],
+				metadata: { department: "engineering" }
+			};
+			const { refreshToken } = tokenManager.generateTokenPair(originalPayload);
+			const newAccessToken = tokenManager.refreshAccessToken(refreshToken);
+			const decoded = tokenManager.verifyAccessToken(newAccessToken);
+			(0, vitest.expect)(decoded.userId).toBe(originalPayload.userId);
+			(0, vitest.expect)(decoded.email).toBe(originalPayload.email);
+			(0, vitest.expect)(decoded.permissions).toEqual(originalPayload.permissions);
+			(0, vitest.expect)(decoded.metadata).toEqual(originalPayload.metadata);
+		});
+	});
+	(0, vitest.describe)("token expiration handling", () => {
+		(0, vitest.it)("should correctly identify token expiration status", () => {
+			const { accessToken } = tokenManager.generateTokenPair(userPayload);
+			(0, vitest.expect)(tokenManager.isTokenExpired(accessToken)).toBe(false);
+			const expiration = tokenManager.getTokenExpiration(accessToken);
+			(0, vitest.expect)(expiration).toBeInstanceOf(Date);
+			(0, vitest.expect)(expiration.getTime()).toBeGreaterThan(Date.now());
+		});
+		(0, vitest.it)("should handle expired tokens correctly", async () => {
+			vitest.vi.useFakeTimers();
+			const shortLivedManager = new require_tokenManager.TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret",
+				accessTokenExpiresIn: "10m"
+			});
+			const { accessToken } = shortLivedManager.generateTokenPair(userPayload);
+			vitest.vi.advanceTimersByTime(1e3 * 60 * 16);
+			(0, vitest.expect)(tokenManager.isTokenExpired(accessToken)).toBe(true);
+			vitest.vi.useRealTimers();
+		});
+		(0, vitest.it)("should decode tokens without verification", () => {
+			const { accessToken } = tokenManager.generateTokenPair(userPayload);
+			const decoded = tokenManager.decodeToken(accessToken);
+			(0, vitest.expect)(decoded).not.toBeNull();
+			(0, vitest.expect)(decoded.userId).toBe(userPayload.userId);
+			(0, vitest.expect)(decoded.email).toBe(userPayload.email);
+		});
+	});
+	(0, vitest.describe)("security validation", () => {
+		(0, vitest.it)("should reject tokens with invalid signatures", () => {
+			const wrongSecretManager = new require_tokenManager.TokenManager({
+				accessTokenSecret: "wrong-secret",
+				refreshTokenSecret: "test-refresh-secret"
+			});
+			const { accessToken } = wrongSecretManager.generateTokenPair(userPayload);
+			(0, vitest.expect)(() => {
+				tokenManager.verifyAccessToken(accessToken);
+			}).toThrow("Invalid access token");
+		});
+		(0, vitest.it)("should reject malformed tokens", () => {
+			(0, vitest.expect)(() => {
+				tokenManager.verifyAccessToken("invalid-token");
+			}).toThrow("Invalid access token");
+			(0, vitest.expect)(() => {
+				tokenManager.verifyRefreshToken("invalid-token");
+			}).toThrow("Invalid refresh token");
+			(0, vitest.expect)(() => {
+				tokenManager.refreshAccessToken("invalid-token");
+			}).toThrow("Invalid refresh token");
+		});
+		(0, vitest.it)("should handle cross-secret validation correctly", () => {
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(userPayload);
+			(0, vitest.expect)(() => {
+				tokenManager.verifyRefreshToken(accessToken);
+			}).toThrow("Invalid refresh token");
+			(0, vitest.expect)(() => {
+				tokenManager.verifyAccessToken(refreshToken);
+			}).toThrow("Invalid access token");
+		});
+	});
+	(0, vitest.describe)("configuration flexibility", () => {
+		(0, vitest.it)("should support custom expiration times", () => {
+			const customManager = new require_tokenManager.TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret",
+				accessTokenExpiresIn: "1h",
+				refreshTokenExpiresIn: "30d"
+			});
+			const { accessToken, refreshToken } = customManager.generateTokenPair(userPayload);
+			const accessDecoded = customManager.verifyAccessToken(accessToken);
+			const refreshDecoded = customManager.verifyRefreshToken(refreshToken);
+			const accessExpTime = (accessDecoded.exp - accessDecoded.iat) * 1e3;
+			const refreshExpTime = (refreshDecoded.exp - refreshDecoded.iat) * 1e3;
+			(0, vitest.expect)(accessExpTime).toBeGreaterThan(55 * 60 * 1e3);
+			(0, vitest.expect)(accessExpTime).toBeLessThan(65 * 60 * 1e3);
+			(0, vitest.expect)(refreshExpTime).toBeGreaterThan(29 * 24 * 60 * 60 * 1e3);
+			(0, vitest.expect)(refreshExpTime).toBeLessThan(31 * 24 * 60 * 60 * 1e3);
+		});
+		(0, vitest.it)("should use default expiration times", () => {
+			const defaultManager = new require_tokenManager.TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret"
+			});
+			const { accessToken, refreshToken } = defaultManager.generateTokenPair(userPayload);
+			const accessDecoded = defaultManager.verifyAccessToken(accessToken);
+			const refreshDecoded = defaultManager.verifyRefreshToken(refreshToken);
+			const accessExpTime = (accessDecoded.exp - accessDecoded.iat) * 1e3;
+			const refreshExpTime = (refreshDecoded.exp - refreshDecoded.iat) * 1e3;
+			(0, vitest.expect)(accessExpTime).toBeGreaterThan(14 * 60 * 1e3);
+			(0, vitest.expect)(accessExpTime).toBeLessThan(16 * 60 * 1e3);
+			(0, vitest.expect)(refreshExpTime).toBeGreaterThan(6 * 24 * 60 * 60 * 1e3);
+			(0, vitest.expect)(refreshExpTime).toBeLessThan(8 * 24 * 60 * 60 * 1e3);
+		});
+	});
+	(0, vitest.describe)("edge cases and error handling", () => {
+		(0, vitest.it)("should handle empty payload gracefully", () => {
+			const emptyPayload = { userId: "" };
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(emptyPayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			(0, vitest.expect)(accessDecoded.userId).toBe("");
+			(0, vitest.expect)(refreshDecoded.userId).toBe("");
+		});
+		(0, vitest.it)("should handle large payloads correctly", () => {
+			const largePayload = {
+				userId: "user123",
+				permissions: Array.from({ length: 100 }, (_, i) => `permission_${i}`),
+				metadata: {
+					department: "engineering",
+					team: "platform",
+					projects: Array.from({ length: 50 }, (_, i) => `project_${i}`)
+				}
+			};
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(largePayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			(0, vitest.expect)(accessDecoded.userId).toBe(largePayload.userId);
+			(0, vitest.expect)(accessDecoded.permissions).toEqual(largePayload.permissions);
+			(0, vitest.expect)(accessDecoded.metadata).toEqual(largePayload.metadata);
+			(0, vitest.expect)(refreshDecoded.userId).toBe(largePayload.userId);
+			(0, vitest.expect)(refreshDecoded.permissions).toEqual(largePayload.permissions);
+			(0, vitest.expect)(refreshDecoded.metadata).toEqual(largePayload.metadata);
+		});
+		(0, vitest.it)("should return null for completely invalid tokens", () => {
+			(0, vitest.expect)(tokenManager.decodeToken("")).toBeNull();
+			(0, vitest.expect)(tokenManager.decodeToken("not.a.token")).toBeNull();
+			(0, vitest.expect)(tokenManager.decodeToken("invalid-token")).toBeNull();
+			(0, vitest.expect)(tokenManager.getTokenExpiration("")).toBeNull();
+			(0, vitest.expect)(tokenManager.getTokenExpiration("not.a.token")).toBeNull();
+			(0, vitest.expect)(tokenManager.getTokenExpiration("invalid-token")).toBeNull();
+			(0, vitest.expect)(tokenManager.isTokenExpired("")).toBe(true);
+			(0, vitest.expect)(tokenManager.isTokenExpired("not.a.token")).toBe(true);
+			(0, vitest.expect)(tokenManager.isTokenExpired("invalid-token")).toBe(true);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/tokenManager.spec.mjs

@@ -0,0 +1,196 @@
+import { TokenManager } from "../tokenManager-BVXxfHRa.mjs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+//#region src/__tests__/tokenManager.spec.ts
+describe("TokenManager", () => {
+	let tokenManager;
+	let userPayload;
+	beforeEach(() => {
+		tokenManager = new TokenManager({
+			accessTokenSecret: "test-access-secret",
+			refreshTokenSecret: "test-refresh-secret",
+			accessTokenExpiresIn: "15m",
+			refreshTokenExpiresIn: "7d"
+		});
+		userPayload = {
+			userId: "user123",
+			email: "test@example.com",
+			role: "admin"
+		};
+	});
+	describe("token generation and verification workflow", () => {
+		it("should generate and verify complete token pair", () => {
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(userPayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			expect(accessDecoded.userId).toBe(userPayload.userId);
+			expect(accessDecoded.email).toBe(userPayload.email);
+			expect(accessDecoded.role).toBe(userPayload.role);
+			expect(refreshDecoded.userId).toBe(userPayload.userId);
+			expect(refreshDecoded.email).toBe(userPayload.email);
+			expect(refreshDecoded.role).toBe(userPayload.role);
+		});
+		it("should handle complete token refresh workflow", () => {
+			const { refreshToken } = tokenManager.generateTokenPair(userPayload);
+			const newAccessToken = tokenManager.refreshAccessToken(refreshToken);
+			const newDecoded = tokenManager.verifyAccessToken(newAccessToken);
+			expect(newDecoded.userId).toBe(userPayload.userId);
+			expect(newDecoded.email).toBe(userPayload.email);
+			expect(newDecoded.role).toBe(userPayload.role);
+			expect(newDecoded.iat).toBeDefined();
+			expect(newDecoded.exp).toBeDefined();
+		});
+		it("should maintain payload integrity through refresh cycle", () => {
+			const originalPayload = {
+				userId: "user456",
+				email: "user@example.com",
+				permissions: ["read", "write"],
+				metadata: { department: "engineering" }
+			};
+			const { refreshToken } = tokenManager.generateTokenPair(originalPayload);
+			const newAccessToken = tokenManager.refreshAccessToken(refreshToken);
+			const decoded = tokenManager.verifyAccessToken(newAccessToken);
+			expect(decoded.userId).toBe(originalPayload.userId);
+			expect(decoded.email).toBe(originalPayload.email);
+			expect(decoded.permissions).toEqual(originalPayload.permissions);
+			expect(decoded.metadata).toEqual(originalPayload.metadata);
+		});
+	});
+	describe("token expiration handling", () => {
+		it("should correctly identify token expiration status", () => {
+			const { accessToken } = tokenManager.generateTokenPair(userPayload);
+			expect(tokenManager.isTokenExpired(accessToken)).toBe(false);
+			const expiration = tokenManager.getTokenExpiration(accessToken);
+			expect(expiration).toBeInstanceOf(Date);
+			expect(expiration.getTime()).toBeGreaterThan(Date.now());
+		});
+		it("should handle expired tokens correctly", async () => {
+			vi.useFakeTimers();
+			const shortLivedManager = new TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret",
+				accessTokenExpiresIn: "10m"
+			});
+			const { accessToken } = shortLivedManager.generateTokenPair(userPayload);
+			vi.advanceTimersByTime(1e3 * 60 * 16);
+			expect(tokenManager.isTokenExpired(accessToken)).toBe(true);
+			vi.useRealTimers();
+		});
+		it("should decode tokens without verification", () => {
+			const { accessToken } = tokenManager.generateTokenPair(userPayload);
+			const decoded = tokenManager.decodeToken(accessToken);
+			expect(decoded).not.toBeNull();
+			expect(decoded.userId).toBe(userPayload.userId);
+			expect(decoded.email).toBe(userPayload.email);
+		});
+	});
+	describe("security validation", () => {
+		it("should reject tokens with invalid signatures", () => {
+			const wrongSecretManager = new TokenManager({
+				accessTokenSecret: "wrong-secret",
+				refreshTokenSecret: "test-refresh-secret"
+			});
+			const { accessToken } = wrongSecretManager.generateTokenPair(userPayload);
+			expect(() => {
+				tokenManager.verifyAccessToken(accessToken);
+			}).toThrow("Invalid access token");
+		});
+		it("should reject malformed tokens", () => {
+			expect(() => {
+				tokenManager.verifyAccessToken("invalid-token");
+			}).toThrow("Invalid access token");
+			expect(() => {
+				tokenManager.verifyRefreshToken("invalid-token");
+			}).toThrow("Invalid refresh token");
+			expect(() => {
+				tokenManager.refreshAccessToken("invalid-token");
+			}).toThrow("Invalid refresh token");
+		});
+		it("should handle cross-secret validation correctly", () => {
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(userPayload);
+			expect(() => {
+				tokenManager.verifyRefreshToken(accessToken);
+			}).toThrow("Invalid refresh token");
+			expect(() => {
+				tokenManager.verifyAccessToken(refreshToken);
+			}).toThrow("Invalid access token");
+		});
+	});
+	describe("configuration flexibility", () => {
+		it("should support custom expiration times", () => {
+			const customManager = new TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret",
+				accessTokenExpiresIn: "1h",
+				refreshTokenExpiresIn: "30d"
+			});
+			const { accessToken, refreshToken } = customManager.generateTokenPair(userPayload);
+			const accessDecoded = customManager.verifyAccessToken(accessToken);
+			const refreshDecoded = customManager.verifyRefreshToken(refreshToken);
+			const accessExpTime = (accessDecoded.exp - accessDecoded.iat) * 1e3;
+			const refreshExpTime = (refreshDecoded.exp - refreshDecoded.iat) * 1e3;
+			expect(accessExpTime).toBeGreaterThan(55 * 60 * 1e3);
+			expect(accessExpTime).toBeLessThan(65 * 60 * 1e3);
+			expect(refreshExpTime).toBeGreaterThan(29 * 24 * 60 * 60 * 1e3);
+			expect(refreshExpTime).toBeLessThan(31 * 24 * 60 * 60 * 1e3);
+		});
+		it("should use default expiration times", () => {
+			const defaultManager = new TokenManager({
+				accessTokenSecret: "test-access-secret",
+				refreshTokenSecret: "test-refresh-secret"
+			});
+			const { accessToken, refreshToken } = defaultManager.generateTokenPair(userPayload);
+			const accessDecoded = defaultManager.verifyAccessToken(accessToken);
+			const refreshDecoded = defaultManager.verifyRefreshToken(refreshToken);
+			const accessExpTime = (accessDecoded.exp - accessDecoded.iat) * 1e3;
+			const refreshExpTime = (refreshDecoded.exp - refreshDecoded.iat) * 1e3;
+			expect(accessExpTime).toBeGreaterThan(14 * 60 * 1e3);
+			expect(accessExpTime).toBeLessThan(16 * 60 * 1e3);
+			expect(refreshExpTime).toBeGreaterThan(6 * 24 * 60 * 60 * 1e3);
+			expect(refreshExpTime).toBeLessThan(8 * 24 * 60 * 60 * 1e3);
+		});
+	});
+	describe("edge cases and error handling", () => {
+		it("should handle empty payload gracefully", () => {
+			const emptyPayload = { userId: "" };
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(emptyPayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			expect(accessDecoded.userId).toBe("");
+			expect(refreshDecoded.userId).toBe("");
+		});
+		it("should handle large payloads correctly", () => {
+			const largePayload = {
+				userId: "user123",
+				permissions: Array.from({ length: 100 }, (_, i) => `permission_${i}`),
+				metadata: {
+					department: "engineering",
+					team: "platform",
+					projects: Array.from({ length: 50 }, (_, i) => `project_${i}`)
+				}
+			};
+			const { accessToken, refreshToken } = tokenManager.generateTokenPair(largePayload);
+			const accessDecoded = tokenManager.verifyAccessToken(accessToken);
+			const refreshDecoded = tokenManager.verifyRefreshToken(refreshToken);
+			expect(accessDecoded.userId).toBe(largePayload.userId);
+			expect(accessDecoded.permissions).toEqual(largePayload.permissions);
+			expect(accessDecoded.metadata).toEqual(largePayload.metadata);
+			expect(refreshDecoded.userId).toBe(largePayload.userId);
+			expect(refreshDecoded.permissions).toEqual(largePayload.permissions);
+			expect(refreshDecoded.metadata).toEqual(largePayload.metadata);
+		});
+		it("should return null for completely invalid tokens", () => {
+			expect(tokenManager.decodeToken("")).toBeNull();
+			expect(tokenManager.decodeToken("not.a.token")).toBeNull();
+			expect(tokenManager.decodeToken("invalid-token")).toBeNull();
+			expect(tokenManager.getTokenExpiration("")).toBeNull();
+			expect(tokenManager.getTokenExpiration("not.a.token")).toBeNull();
+			expect(tokenManager.getTokenExpiration("invalid-token")).toBeNull();
+			expect(tokenManager.isTokenExpired("")).toBe(true);
+			expect(tokenManager.isTokenExpired("not.a.token")).toBe(true);
+			expect(tokenManager.isTokenExpired("invalid-token")).toBe(true);
+		});
+	});
+});
+
+//#endregion

package/dist/cacheTokenStorage-Ca05vf3T.mjs

@@ -0,0 +1,31 @@
+//#region src/cacheTokenStorage.ts
+var CacheTokenStorage = class {
+	cache;
+	accessTokenKey;
+	refreshTokenKey;
+	constructor(cache, accessTokenKey = "access_token", refreshTokenKey = "refresh_token") {
+		this.cache = cache;
+		this.accessTokenKey = accessTokenKey;
+		this.refreshTokenKey = refreshTokenKey;
+	}
+	async getAccessToken() {
+		const token = await this.cache.get(this.accessTokenKey);
+		return token || null;
+	}
+	async setAccessToken(token, ttl) {
+		await this.cache.set(this.accessTokenKey, token, ttl);
+	}
+	async getRefreshToken() {
+		const token = await this.cache.get(this.refreshTokenKey);
+		return token || null;
+	}
+	async setRefreshToken(token, ttl) {
+		await this.cache.set(this.refreshTokenKey, token, ttl);
+	}
+	async clearTokens() {
+		await Promise.all([this.cache.delete(this.accessTokenKey), this.cache.delete(this.refreshTokenKey)]);
+	}
+};
+
+//#endregion
+export { CacheTokenStorage };

package/dist/cacheTokenStorage-CvptztkW.cjs

@@ -0,0 +1,37 @@
+
+//#region src/cacheTokenStorage.ts
+var CacheTokenStorage = class {
+	cache;
+	accessTokenKey;
+	refreshTokenKey;
+	constructor(cache, accessTokenKey = "access_token", refreshTokenKey = "refresh_token") {
+		this.cache = cache;
+		this.accessTokenKey = accessTokenKey;
+		this.refreshTokenKey = refreshTokenKey;
+	}
+	async getAccessToken() {
+		const token = await this.cache.get(this.accessTokenKey);
+		return token || null;
+	}
+	async setAccessToken(token, ttl) {
+		await this.cache.set(this.accessTokenKey, token, ttl);
+	}
+	async getRefreshToken() {
+		const token = await this.cache.get(this.refreshTokenKey);
+		return token || null;
+	}
+	async setRefreshToken(token, ttl) {
+		await this.cache.set(this.refreshTokenKey, token, ttl);
+	}
+	async clearTokens() {
+		await Promise.all([this.cache.delete(this.accessTokenKey), this.cache.delete(this.refreshTokenKey)]);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'CacheTokenStorage', {
+  enumerable: true,
+  get: function () {
+    return CacheTokenStorage;
+  }
+});

package/dist/cacheTokenStorage.cjs

@@ -0,0 +1,3 @@
+const require_cacheTokenStorage = require('./cacheTokenStorage-CvptztkW.cjs');
+
+exports.CacheTokenStorage = require_cacheTokenStorage.CacheTokenStorage;

package/dist/cacheTokenStorage.mjs

@@ -0,0 +1,3 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-Ca05vf3T.mjs";
+
+export { CacheTokenStorage };

package/dist/chunk-DWy1uDak.cjs

@@ -0,0 +1,39 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/client-DaiUm0UZ.cjs

@@ -0,0 +1,155 @@
+
+//#region src/client.ts
+var LocalStorageTokenStorage = class {
+	accessTokenKey;
+	refreshTokenKey;
+	constructor(accessTokenKey = "access_token", refreshTokenKey = "refresh_token") {
+		this.accessTokenKey = accessTokenKey;
+		this.refreshTokenKey = refreshTokenKey;
+	}
+	getAccessToken() {
+		if (typeof window === "undefined") return null;
+		return localStorage.getItem(this.accessTokenKey);
+	}
+	setAccessToken(token, ttl) {
+		if (typeof window === "undefined") return;
+		localStorage.setItem(this.accessTokenKey, token);
+	}
+	getRefreshToken() {
+		if (typeof window === "undefined") return null;
+		return localStorage.getItem(this.refreshTokenKey);
+	}
+	setRefreshToken(token, ttl) {
+		if (typeof window === "undefined") return;
+		localStorage.setItem(this.refreshTokenKey, token);
+	}
+	clearTokens() {
+		if (typeof window === "undefined") return;
+		localStorage.removeItem(this.accessTokenKey);
+		localStorage.removeItem(this.refreshTokenKey);
+	}
+};
+var MemoryTokenStorage = class {
+	accessToken = null;
+	refreshToken = null;
+	getAccessToken() {
+		return this.accessToken;
+	}
+	setAccessToken(token, ttl) {
+		this.accessToken = token;
+	}
+	getRefreshToken() {
+		return this.refreshToken;
+	}
+	setRefreshToken(token, ttl) {
+		this.refreshToken = token;
+	}
+	clearTokens() {
+		this.accessToken = null;
+		this.refreshToken = null;
+	}
+};
+var TokenClient = class {
+	storage;
+	refreshEndpoint;
+	onTokenRefresh;
+	onTokenExpired;
+	constructor(options = {}) {
+		this.storage = options.storage || new LocalStorageTokenStorage();
+		this.refreshEndpoint = options.refreshEndpoint;
+		this.onTokenRefresh = options.onTokenRefresh;
+		this.onTokenExpired = options.onTokenExpired;
+	}
+	async getAccessToken() {
+		return await this.storage.getAccessToken();
+	}
+	async getRefreshToken() {
+		return await this.storage.getRefreshToken();
+	}
+	async setTokens(accessToken, refreshToken, accessTtl, refreshTtl) {
+		await this.storage.setAccessToken(accessToken, accessTtl);
+		if (refreshToken) await this.storage.setRefreshToken(refreshToken, refreshTtl);
+	}
+	async clearTokens() {
+		await this.storage.clearTokens();
+	}
+	isTokenExpired(token) {
+		try {
+			const payload = JSON.parse(atob(token.split(".")[1]));
+			const now = Math.floor(Date.now() / 1e3);
+			return payload.exp < now;
+		} catch {
+			return true;
+		}
+	}
+	getTokenExpiration(token) {
+		try {
+			const payload = JSON.parse(atob(token.split(".")[1]));
+			return new Date(payload.exp * 1e3);
+		} catch {
+			return null;
+		}
+	}
+	async refreshTokens() {
+		const refreshToken = await this.getRefreshToken();
+		if (!refreshToken || !this.refreshEndpoint) return false;
+		try {
+			const response = await fetch(this.refreshEndpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ refreshToken })
+			});
+			if (!response.ok) throw new Error("Failed to refresh token");
+			const data = await response.json();
+			const { accessToken, refreshToken: newRefreshToken } = data;
+			await this.setTokens(accessToken, newRefreshToken);
+			if (this.onTokenRefresh) this.onTokenRefresh({
+				accessToken,
+				refreshToken: newRefreshToken
+			});
+			return true;
+		} catch (error) {
+			await this.clearTokens();
+			if (this.onTokenExpired) this.onTokenExpired();
+			return false;
+		}
+	}
+	async getValidAccessToken() {
+		const accessToken = await this.getAccessToken();
+		if (!accessToken) return null;
+		if (this.isTokenExpired(accessToken)) {
+			const refreshed = await this.refreshTokens();
+			if (!refreshed) return null;
+			return await this.getAccessToken();
+		}
+		return accessToken;
+	}
+	async createAuthHeaders() {
+		const token = await this.getAccessToken();
+		return token ? { Authorization: `Bearer ${token}` } : {};
+	}
+	async createValidAuthHeaders() {
+		const token = await this.getValidAccessToken();
+		return token ? { Authorization: `Bearer ${token}` } : {};
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'LocalStorageTokenStorage', {
+  enumerable: true,
+  get: function () {
+    return LocalStorageTokenStorage;
+  }
+});
+Object.defineProperty(exports, 'MemoryTokenStorage', {
+  enumerable: true,
+  get: function () {
+    return MemoryTokenStorage;
+  }
+});
+Object.defineProperty(exports, 'TokenClient', {
+  enumerable: true,
+  get: function () {
+    return TokenClient;
+  }
+});