@geekmidas/cache 0.0.2 → 0.0.4

package/dist/__tests__/cache.spec.mjs

@@ -1,38 +1,38 @@
-import { describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
-import { InMemoryCache } from "../memory-YteQXj7m.mjs";
-import { UpstashCache } from "../upstash-_05vyc5o.mjs";
+import { InMemoryCache } from "../memory-NQi0XmZ2.mjs";
+import { UpstashCache } from "../upstash-CTY-M8vR.mjs";
+import { describe, expect, it } from "vitest";
 
 //#region src/__tests__/cache.spec.ts
 describe("Cache Interface", () => {
 	describe("interface compliance", () => {
 		it("InMemoryCache should implement Cache interface", () => {
 			const cache = new InMemoryCache();
-			globalExpect(typeof cache.get).toBe("function");
-			globalExpect(typeof cache.set).toBe("function");
-			globalExpect(typeof cache.delete).toBe("function");
+			expect(typeof cache.get).toBe("function");
+			expect(typeof cache.set).toBe("function");
+			expect(typeof cache.delete).toBe("function");
 		});
 		it("UpstashCache should implement Cache interface", () => {
 			const cache = new UpstashCache("http://localhost:8079", "example_token");
-			globalExpect(typeof cache.get).toBe("function");
-			globalExpect(typeof cache.set).toBe("function");
-			globalExpect(typeof cache.delete).toBe("function");
+			expect(typeof cache.get).toBe("function");
+			expect(typeof cache.set).toBe("function");
+			expect(typeof cache.delete).toBe("function");
 		});
 	});
 	describe("method signatures", () => {
 		it("should have correct get method signature", () => {
 			const cache = new InMemoryCache();
 			const getResult = cache.get("test");
-			globalExpect(getResult).toBeInstanceOf(Promise);
+			expect(getResult).toBeInstanceOf(Promise);
 		});
 		it("should have correct set method signature", () => {
 			const cache = new InMemoryCache();
 			const setResult = cache.set("test", "value");
-			globalExpect(setResult).toBeInstanceOf(Promise);
+			expect(setResult).toBeInstanceOf(Promise);
 		});
 		it("should have correct delete method signature", () => {
 			const cache = new InMemoryCache();
 			const deleteResult = cache.delete("test");
-			globalExpect(deleteResult).toBeInstanceOf(Promise);
+			expect(deleteResult).toBeInstanceOf(Promise);
 		});
 	});
 	describe("generic type support", () => {
@@ -40,13 +40,13 @@ describe("Cache Interface", () => {
 			const cache = new InMemoryCache();
 			await cache.set("key", "value");
 			const result = await cache.get("key");
-			globalExpect(typeof result === "string" || result === void 0).toBe(true);
+			expect(typeof result === "string" || result === void 0).toBe(true);
 		});
 		it("should support number types", async () => {
 			const cache = new InMemoryCache();
 			await cache.set("key", 42);
 			const result = await cache.get("key");
-			globalExpect(typeof result === "number" || result === void 0).toBe(true);
+			expect(typeof result === "number" || result === void 0).toBe(true);
 		});
 		it("should support object types", async () => {
 			const cache = new InMemoryCache();
@@ -56,7 +56,7 @@ describe("Cache Interface", () => {
 			};
 			await cache.set("user", user);
 			const result = await cache.get("user");
-			globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
+			expect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
 		});
 		it("should support union types", async () => {
 			const cache = new InMemoryCache();
@@ -66,9 +66,9 @@ describe("Cache Interface", () => {
 			const stringResult = await cache.get("string");
 			const numberResult = await cache.get("number");
 			const booleanResult = await cache.get("boolean");
-			globalExpect(stringResult).toBe("text");
-			globalExpect(numberResult).toBe(42);
-			globalExpect(booleanResult).toBe(true);
+			expect(stringResult).toBe("text");
+			expect(numberResult).toBe(42);
+			expect(booleanResult).toBe(true);
 		});
 	});
 });

package/dist/__tests__/integration.spec.cjs

@@ -1,30 +1,31 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
 const require_memory = require('../memory-n6Iosq6J.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/integration.spec.ts
-require_vi_DgezovHB.describe("Cache Integration Tests", () => {
+(0, vitest.describe)("Cache Integration Tests", () => {
 	let memoryCache;
-	require_vi_DgezovHB.beforeEach(() => {
+	(0, vitest.beforeEach)(() => {
 		memoryCache = new require_memory.InMemoryCache();
 	});
-	require_vi_DgezovHB.describe("cross-cache behavior consistency", () => {
+	(0, vitest.describe)("cross-cache behavior consistency", () => {
 		const testCases = [{
 			name: "InMemoryCache",
 			cache: () => new require_memory.InMemoryCache()
 		}];
 		testCases.forEach(({ name, cache }) => {
-			require_vi_DgezovHB.describe(name, () => {
+			(0, vitest.describe)(name, () => {
 				let cacheInstance;
-				require_vi_DgezovHB.beforeEach(() => {
+				(0, vitest.beforeEach)(() => {
 					cacheInstance = cache();
 				});
-				require_vi_DgezovHB.it("should handle basic CRUD operations", async () => {
+				(0, vitest.it)("should handle basic CRUD operations", async () => {
 					await cacheInstance.set("user:1", {
 						id: 1,
 						name: "John"
 					});
 					const user = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(user).toEqual({
+					(0, vitest.expect)(user).toEqual({
 						id: 1,
 						name: "John"
 					});
@@ -33,15 +34,15 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 						name: "Jane"
 					});
 					const updatedUser = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(updatedUser).toEqual({
+					(0, vitest.expect)(updatedUser).toEqual({
 						id: 1,
 						name: "Jane"
 					});
 					await cacheInstance.delete("user:1");
 					const deletedUser = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(deletedUser).toBeUndefined();
+					(0, vitest.expect)(deletedUser).toBeUndefined();
 				});
-				require_vi_DgezovHB.it("should handle concurrent operations", async () => {
+				(0, vitest.it)("should handle concurrent operations", async () => {
 					const operations = [
 						cacheInstance.set("key1", "value1"),
 						cacheInstance.set("key2", "value2"),
@@ -53,13 +54,13 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 						cacheInstance.get("key2"),
 						cacheInstance.get("key3")
 					]);
-					require_vi_DgezovHB.globalExpect(results).toEqual([
+					(0, vitest.expect)(results).toEqual([
 						"value1",
 						"value2",
 						"value3"
 					]);
 				});
-				require_vi_DgezovHB.it("should handle data type preservation", async () => {
+				(0, vitest.it)("should handle data type preservation", async () => {
 					const testData = {
 						string: "hello",
 						number: 42,
@@ -74,31 +75,31 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 					};
 					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
 					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					require_vi_DgezovHB.globalExpect(results[0]).toBe("hello");
-					require_vi_DgezovHB.globalExpect(results[1]).toBe(42);
-					require_vi_DgezovHB.globalExpect(results[2]).toBe(true);
-					require_vi_DgezovHB.globalExpect(results[3]).toEqual({ nested: true });
-					require_vi_DgezovHB.globalExpect(results[4]).toEqual([
+					(0, vitest.expect)(results[0]).toBe("hello");
+					(0, vitest.expect)(results[1]).toBe(42);
+					(0, vitest.expect)(results[2]).toBe(true);
+					(0, vitest.expect)(results[3]).toEqual({ nested: true });
+					(0, vitest.expect)(results[4]).toEqual([
 						1,
 						2,
 						3
 					]);
-					require_vi_DgezovHB.globalExpect(results[5]).toBeNull();
+					(0, vitest.expect)(results[5]).toBeNull();
 				});
-				require_vi_DgezovHB.it("should handle key isolation", async () => {
+				(0, vitest.it)("should handle key isolation", async () => {
 					await cacheInstance.set("user:1", "User One");
 					await cacheInstance.set("user:2", "User Two");
 					await cacheInstance.set("session:1", "Session One");
 					await cacheInstance.delete("user:1");
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
+					(0, vitest.expect)(await cacheInstance.get("user:1")).toBeUndefined();
+					(0, vitest.expect)(await cacheInstance.get("user:2")).toBe("User Two");
+					(0, vitest.expect)(await cacheInstance.get("session:1")).toBe("Session One");
 				});
 			});
 		});
 	});
-	require_vi_DgezovHB.describe("cache migration scenarios", () => {
-		require_vi_DgezovHB.it("should support migrating data between cache implementations", async () => {
+	(0, vitest.describe)("cache migration scenarios", () => {
+		(0, vitest.it)("should support migrating data between cache implementations", async () => {
 			const sourceCache = new require_memory.InMemoryCache();
 			const targetCache = new require_memory.InMemoryCache();
 			const testData = {
@@ -123,12 +124,12 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			}
 			for (const [key, expectedValue] of Object.entries(testData)) {
 				const migratedValue = await targetCache.get(key);
-				require_vi_DgezovHB.globalExpect(migratedValue).toEqual(expectedValue);
+				(0, vitest.expect)(migratedValue).toEqual(expectedValue);
 			}
 		});
 	});
-	require_vi_DgezovHB.describe("cache abstraction patterns", () => {
-		require_vi_DgezovHB.it("should support cache factory pattern", async () => {
+	(0, vitest.describe)("cache abstraction patterns", () => {
+		(0, vitest.it)("should support cache factory pattern", async () => {
 			const createCache = (type) => {
 				switch (type) {
 					case "memory": return new require_memory.InMemoryCache();
@@ -142,13 +143,13 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 				name: "John"
 			});
 			await sessionCache.set("session:abc", "active");
-			require_vi_DgezovHB.globalExpect(await userCache.get("user:1")).toEqual({
+			(0, vitest.expect)(await userCache.get("user:1")).toEqual({
 				id: 1,
 				name: "John"
 			});
-			require_vi_DgezovHB.globalExpect(await sessionCache.get("session:abc")).toBe("active");
+			(0, vitest.expect)(await sessionCache.get("session:abc")).toBe("active");
 		});
-		require_vi_DgezovHB.it("should support cache wrapper pattern", async () => {
+		(0, vitest.it)("should support cache wrapper pattern", async () => {
 			class LoggingCache {
 				logs = [];
 				constructor(underlying) {
@@ -176,28 +177,28 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			await loggingCache.get("test");
 			await loggingCache.delete("test");
 			const logs = loggingCache.getLogs();
-			require_vi_DgezovHB.globalExpect(logs).toEqual([
+			(0, vitest.expect)(logs).toEqual([
 				"SET test",
 				"GET test",
 				"DELETE test"
 			]);
 		});
 	});
-	require_vi_DgezovHB.describe("performance and stress tests", () => {
-		require_vi_DgezovHB.it("should handle large number of operations", async () => {
+	(0, vitest.describe)("performance and stress tests", () => {
+		(0, vitest.it)("should handle large number of operations", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const operationCount = 1e3;
 			const insertPromises = Array.from({ length: operationCount }, (_, i) => cache.set(`key:${i}`, i));
 			await Promise.all(insertPromises);
 			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
 			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) require_vi_DgezovHB.globalExpect(results[i]).toBe(i);
+			for (let i = 0; i < operationCount; i++) (0, vitest.expect)(results[i]).toBe(i);
 			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
 			await Promise.all(deletePromises);
 			const postDeleteRead = await cache.get("key:0");
-			require_vi_DgezovHB.globalExpect(postDeleteRead).toBeUndefined();
+			(0, vitest.expect)(postDeleteRead).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should handle large objects efficiently", async () => {
+		(0, vitest.it)("should handle large objects efficiently", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const largeObject = {
 				id: 1,
@@ -214,19 +215,19 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			await cache.set("large-object", largeObject);
 			const result = await cache.get("large-object");
 			const endTime = Date.now();
-			require_vi_DgezovHB.globalExpect(result).toEqual(largeObject);
-			require_vi_DgezovHB.globalExpect(endTime - startTime).toBeLessThan(100);
+			(0, vitest.expect)(result).toEqual(largeObject);
+			(0, vitest.expect)(endTime - startTime).toBeLessThan(100);
 		});
 	});
-	require_vi_DgezovHB.describe("error scenarios", () => {
-		require_vi_DgezovHB.it("should handle operations after errors gracefully", async () => {
+	(0, vitest.describe)("error scenarios", () => {
+		(0, vitest.it)("should handle operations after errors gracefully", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("valid-key", "valid-value");
-			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBe("valid-value");
+			(0, vitest.expect)(await cache.get("valid-key")).toBe("valid-value");
 			await cache.set("another-key", "another-value");
-			require_vi_DgezovHB.globalExpect(await cache.get("another-key")).toBe("another-value");
+			(0, vitest.expect)(await cache.get("another-key")).toBe("another-value");
 			await cache.delete("valid-key");
-			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBeUndefined();
+			(0, vitest.expect)(await cache.get("valid-key")).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/integration.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/integration.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/integration.spec.mjs

@@ -1,5 +1,5 @@
-import { beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
-import { InMemoryCache } from "../memory-YteQXj7m.mjs";
+import { InMemoryCache } from "../memory-NQi0XmZ2.mjs";
+import { beforeEach, describe, expect, it } from "vitest";
 
 //#region src/__tests__/integration.spec.ts
 describe("Cache Integration Tests", () => {
@@ -24,7 +24,7 @@ describe("Cache Integration Tests", () => {
 						name: "John"
 					});
 					const user = await cacheInstance.get("user:1");
-					globalExpect(user).toEqual({
+					expect(user).toEqual({
 						id: 1,
 						name: "John"
 					});
@@ -33,13 +33,13 @@ describe("Cache Integration Tests", () => {
 						name: "Jane"
 					});
 					const updatedUser = await cacheInstance.get("user:1");
-					globalExpect(updatedUser).toEqual({
+					expect(updatedUser).toEqual({
 						id: 1,
 						name: "Jane"
 					});
 					await cacheInstance.delete("user:1");
 					const deletedUser = await cacheInstance.get("user:1");
-					globalExpect(deletedUser).toBeUndefined();
+					expect(deletedUser).toBeUndefined();
 				});
 				it("should handle concurrent operations", async () => {
 					const operations = [
@@ -53,7 +53,7 @@ describe("Cache Integration Tests", () => {
 						cacheInstance.get("key2"),
 						cacheInstance.get("key3")
 					]);
-					globalExpect(results).toEqual([
+					expect(results).toEqual([
 						"value1",
 						"value2",
 						"value3"
@@ -74,25 +74,25 @@ describe("Cache Integration Tests", () => {
 					};
 					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
 					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					globalExpect(results[0]).toBe("hello");
-					globalExpect(results[1]).toBe(42);
-					globalExpect(results[2]).toBe(true);
-					globalExpect(results[3]).toEqual({ nested: true });
-					globalExpect(results[4]).toEqual([
+					expect(results[0]).toBe("hello");
+					expect(results[1]).toBe(42);
+					expect(results[2]).toBe(true);
+					expect(results[3]).toEqual({ nested: true });
+					expect(results[4]).toEqual([
 						1,
 						2,
 						3
 					]);
-					globalExpect(results[5]).toBeNull();
+					expect(results[5]).toBeNull();
 				});
 				it("should handle key isolation", async () => {
 					await cacheInstance.set("user:1", "User One");
 					await cacheInstance.set("user:2", "User Two");
 					await cacheInstance.set("session:1", "Session One");
 					await cacheInstance.delete("user:1");
-					globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
-					globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
-					globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
+					expect(await cacheInstance.get("user:1")).toBeUndefined();
+					expect(await cacheInstance.get("user:2")).toBe("User Two");
+					expect(await cacheInstance.get("session:1")).toBe("Session One");
 				});
 			});
 		});
@@ -123,7 +123,7 @@ describe("Cache Integration Tests", () => {
 			}
 			for (const [key, expectedValue] of Object.entries(testData)) {
 				const migratedValue = await targetCache.get(key);
-				globalExpect(migratedValue).toEqual(expectedValue);
+				expect(migratedValue).toEqual(expectedValue);
 			}
 		});
 	});
@@ -142,11 +142,11 @@ describe("Cache Integration Tests", () => {
 				name: "John"
 			});
 			await sessionCache.set("session:abc", "active");
-			globalExpect(await userCache.get("user:1")).toEqual({
+			expect(await userCache.get("user:1")).toEqual({
 				id: 1,
 				name: "John"
 			});
-			globalExpect(await sessionCache.get("session:abc")).toBe("active");
+			expect(await sessionCache.get("session:abc")).toBe("active");
 		});
 		it("should support cache wrapper pattern", async () => {
 			class LoggingCache {
@@ -176,7 +176,7 @@ describe("Cache Integration Tests", () => {
 			await loggingCache.get("test");
 			await loggingCache.delete("test");
 			const logs = loggingCache.getLogs();
-			globalExpect(logs).toEqual([
+			expect(logs).toEqual([
 				"SET test",
 				"GET test",
 				"DELETE test"
@@ -191,11 +191,11 @@ describe("Cache Integration Tests", () => {
 			await Promise.all(insertPromises);
 			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
 			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) globalExpect(results[i]).toBe(i);
+			for (let i = 0; i < operationCount; i++) expect(results[i]).toBe(i);
 			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
 			await Promise.all(deletePromises);
 			const postDeleteRead = await cache.get("key:0");
-			globalExpect(postDeleteRead).toBeUndefined();
+			expect(postDeleteRead).toBeUndefined();
 		});
 		it("should handle large objects efficiently", async () => {
 			const cache = new InMemoryCache();
@@ -214,19 +214,19 @@ describe("Cache Integration Tests", () => {
 			await cache.set("large-object", largeObject);
 			const result = await cache.get("large-object");
 			const endTime = Date.now();
-			globalExpect(result).toEqual(largeObject);
-			globalExpect(endTime - startTime).toBeLessThan(100);
+			expect(result).toEqual(largeObject);
+			expect(endTime - startTime).toBeLessThan(100);
 		});
 	});
 	describe("error scenarios", () => {
 		it("should handle operations after errors gracefully", async () => {
 			const cache = new InMemoryCache();
 			await cache.set("valid-key", "valid-value");
-			globalExpect(await cache.get("valid-key")).toBe("valid-value");
+			expect(await cache.get("valid-key")).toBe("valid-value");
 			await cache.set("another-key", "another-value");
-			globalExpect(await cache.get("another-key")).toBe("another-value");
+			expect(await cache.get("another-key")).toBe("another-value");
 			await cache.delete("valid-key");
-			globalExpect(await cache.get("valid-key")).toBeUndefined();
+			expect(await cache.get("valid-key")).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/memory.spec.cjs

@@ -1,23 +1,24 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
 const require_memory = require('../memory-n6Iosq6J.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/memory.spec.ts
-require_vi_DgezovHB.describe("InMemoryCache", () => {
+(0, vitest.describe)("InMemoryCache", () => {
 	let cache;
-	require_vi_DgezovHB.beforeEach(() => {
+	(0, vitest.beforeEach)(() => {
 		cache = new require_memory.InMemoryCache();
 	});
-	require_vi_DgezovHB.describe("get", () => {
-		require_vi_DgezovHB.it("should return undefined for non-existent key", async () => {
+	(0, vitest.describe)("get", () => {
+		(0, vitest.it)("should return undefined for non-existent key", async () => {
 			const result = await cache.get("non-existent");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should return value for existing key", async () => {
+		(0, vitest.it)("should return value for existing key", async () => {
 			await cache.set("test-key", "test-value");
 			const result = await cache.get("test-key");
-			require_vi_DgezovHB.globalExpect(result).toBe("test-value");
+			(0, vitest.expect)(result).toBe("test-value");
 		});
-		require_vi_DgezovHB.it("should handle different data types", async () => {
+		(0, vitest.it)("should handle different data types", async () => {
 			const objectValue = {
 				id: 1,
 				name: "test"
@@ -33,91 +34,91 @@ require_vi_DgezovHB.describe("InMemoryCache", () => {
 			await cache.set("array", arrayValue);
 			await cache.set("number", numberValue);
 			await cache.set("boolean", booleanValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("object")).toEqual(objectValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("array")).toEqual(arrayValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("number")).toBe(numberValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("boolean")).toBe(booleanValue);
+			(0, vitest.expect)(await cache.get("object")).toEqual(objectValue);
+			(0, vitest.expect)(await cache.get("array")).toEqual(arrayValue);
+			(0, vitest.expect)(await cache.get("number")).toBe(numberValue);
+			(0, vitest.expect)(await cache.get("boolean")).toBe(booleanValue);
 		});
 	});
-	require_vi_DgezovHB.describe("set", () => {
-		require_vi_DgezovHB.it("should store string value", async () => {
+	(0, vitest.describe)("set", () => {
+		(0, vitest.it)("should store string value", async () => {
 			await cache.set("string-key", "string-value");
 			const result = await cache.get("string-key");
-			require_vi_DgezovHB.globalExpect(result).toBe("string-value");
+			(0, vitest.expect)(result).toBe("string-value");
 		});
-		require_vi_DgezovHB.it("should store object value", async () => {
+		(0, vitest.it)("should store object value", async () => {
 			const value = {
 				id: 1,
 				data: "test"
 			};
 			await cache.set("object-key", value);
 			const result = await cache.get("object-key");
-			require_vi_DgezovHB.globalExpect(result).toEqual(value);
+			(0, vitest.expect)(result).toEqual(value);
 		});
-		require_vi_DgezovHB.it("should overwrite existing value", async () => {
+		(0, vitest.it)("should overwrite existing value", async () => {
 			await cache.set("key", "initial-value");
 			await cache.set("key", "updated-value");
 			const result = await cache.get("key");
-			require_vi_DgezovHB.globalExpect(result).toBe("updated-value");
+			(0, vitest.expect)(result).toBe("updated-value");
 		});
-		require_vi_DgezovHB.it("should handle null values", async () => {
+		(0, vitest.it)("should handle null values", async () => {
 			await cache.set("null-key", null);
 			const result = await cache.get("null-key");
-			require_vi_DgezovHB.globalExpect(result).toBeNull();
+			(0, vitest.expect)(result).toBeNull();
 		});
 	});
-	require_vi_DgezovHB.describe("delete", () => {
-		require_vi_DgezovHB.it("should remove existing key", async () => {
+	(0, vitest.describe)("delete", () => {
+		(0, vitest.it)("should remove existing key", async () => {
 			await cache.set("to-delete", "value");
 			await cache.delete("to-delete");
 			const result = await cache.get("to-delete");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should not throw error for non-existent key", async () => {
-			await require_vi_DgezovHB.globalExpect(cache.delete("non-existent")).resolves.not.toThrow();
+		(0, vitest.it)("should not throw error for non-existent key", async () => {
+			await (0, vitest.expect)(cache.delete("non-existent")).resolves.not.toThrow();
 		});
-		require_vi_DgezovHB.it("should only delete specified key", async () => {
+		(0, vitest.it)("should only delete specified key", async () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.delete("key1");
-			require_vi_DgezovHB.globalExpect(await cache.get("key1")).toBeUndefined();
-			require_vi_DgezovHB.globalExpect(await cache.get("key2")).toBe("value2");
+			(0, vitest.expect)(await cache.get("key1")).toBeUndefined();
+			(0, vitest.expect)(await cache.get("key2")).toBe("value2");
 		});
 	});
-	require_vi_DgezovHB.describe("multiple operations", () => {
-		require_vi_DgezovHB.it("should handle multiple keys independently", async () => {
+	(0, vitest.describe)("multiple operations", () => {
+		(0, vitest.it)("should handle multiple keys independently", async () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.set("key3", "value3");
-			require_vi_DgezovHB.globalExpect(await cache.get("key1")).toBe("value1");
-			require_vi_DgezovHB.globalExpect(await cache.get("key2")).toBe("value2");
-			require_vi_DgezovHB.globalExpect(await cache.get("key3")).toBe("value3");
+			(0, vitest.expect)(await cache.get("key1")).toBe("value1");
+			(0, vitest.expect)(await cache.get("key2")).toBe("value2");
+			(0, vitest.expect)(await cache.get("key3")).toBe("value3");
 		});
-		require_vi_DgezovHB.it("should maintain data integrity across operations", async () => {
+		(0, vitest.it)("should maintain data integrity across operations", async () => {
 			const data = { count: 0 };
 			await cache.set("counter", data);
 			const retrieved = await cache.get("counter");
 			retrieved.count = 5;
 			const original = await cache.get("counter");
-			require_vi_DgezovHB.globalExpect(original.count).toBe(5);
+			(0, vitest.expect)(original.count).toBe(5);
 		});
 	});
-	require_vi_DgezovHB.describe("edge cases", () => {
-		require_vi_DgezovHB.it("should handle empty string as key", async () => {
+	(0, vitest.describe)("edge cases", () => {
+		(0, vitest.it)("should handle empty string as key", async () => {
 			await cache.set("", "empty-key-value");
 			const result = await cache.get("");
-			require_vi_DgezovHB.globalExpect(result).toBe("empty-key-value");
+			(0, vitest.expect)(result).toBe("empty-key-value");
 		});
-		require_vi_DgezovHB.it("should handle special characters in keys", async () => {
+		(0, vitest.it)("should handle special characters in keys", async () => {
 			const specialKey = "key!@#$%^&*()_+{}|:\"<>?[]\\;',./?`~";
 			await cache.set(specialKey, "special-value");
 			const result = await cache.get(specialKey);
-			require_vi_DgezovHB.globalExpect(result).toBe("special-value");
+			(0, vitest.expect)(result).toBe("special-value");
 		});
-		require_vi_DgezovHB.it("should handle undefined values", async () => {
+		(0, vitest.it)("should handle undefined values", async () => {
 			await cache.set("undefined-key", void 0);
 			const result = await cache.get("undefined-key");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/memory.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/memory.spec.d.mts

@@ -0,0 +1 @@
+export { };