@b9g/cache 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/cache",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Universal Cache API for ServiceWorker applications. Provides standard CacheStorage and Cache interfaces across all JavaScript runtimes.",
   "keywords": [
     "cache",
@@ -15,7 +15,7 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
+    "@b9g/libuild": "^0.1.18",
     "bun-types": "latest"
   },
   "type": "module",

package/src/index.d.ts

@@ -17,6 +17,10 @@ export interface CacheQueryOptions {
     /** Custom cache name for scoped operations */
     cacheName?: string;
 }
+/**
+ * Convert RequestInfo or URL to Request
+ */
+export declare function toRequest(request: RequestInfo | URL): Request;
 /**
  * Abstract Cache class implementing the Cache API interface
  * Provides shared implementations for add() and addAll() while requiring
@@ -26,19 +30,19 @@ export declare abstract class Cache {
     /**
      * Returns a Promise that resolves to the response associated with the first matching request
      */
-    abstract match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    abstract match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
     /**
      * Puts a request/response pair into the cache
      */
-    abstract put(request: Request, response: Response): Promise<void>;
+    abstract put(request: RequestInfo | URL, response: Response): Promise<void>;
     /**
      * Finds the cache entry whose key is the request, and if found, deletes it and returns true
      */
-    abstract delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    abstract delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
     /**
      * Returns a Promise that resolves to an array of cache keys (Request objects)
      */
-    abstract keys(request?: Request, options?: CacheQueryOptions): Promise<readonly Request[]>;
+    abstract keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<readonly Request[]>;
     /**
      * Takes a URL, retrieves it and adds the resulting response object to the cache
      * Shared implementation using fetch() and put()
@@ -56,10 +60,10 @@ export declare abstract class Cache {
     matchAll(request?: Request, options?: CacheQueryOptions): Promise<readonly Response[]>;
 }
 /**
- * Generate a cache key from a Request object
+ * Generate a cache key from a Request, string URL, or URL object
  * Normalizes the request for consistent cache key generation
  */
-export declare function generateCacheKey(request: Request, options?: CacheQueryOptions): string;
+export declare function generateCacheKey(request: RequestInfo | URL, options?: CacheQueryOptions): string;
 /**
  * Factory function for creating Cache instances based on cache name
  */

package/src/index.js

@@ -1,5 +1,14 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+function toRequest(request) {
+  if (typeof request === "string") {
+    return new Request(request);
+  }
+  if (request instanceof URL) {
+    return new Request(request.href);
+  }
+  return request;
+}
 var Cache = class {
   /**
    * Takes a URL, retrieves it and adds the resulting response object to the cache
@@ -38,11 +47,12 @@ var Cache = class {
   }
 };
 function generateCacheKey(request, options) {
-  const url = new URL(request.url);
+  const req = toRequest(request);
+  const url = new URL(req.url);
   if (options?.ignoreSearch) {
     url.search = "";
   }
-  const method = options?.ignoreMethod ? "GET" : request.method;
+  const method = options?.ignoreMethod ? "GET" : req.method;
   return `${method}:${url.href}`;
 }
 var CustomCacheStorage = class {
@@ -183,5 +193,6 @@ var CustomCacheStorage = class {
 export {
   Cache,
   CustomCacheStorage,
-  generateCacheKey
+  generateCacheKey,
+  toRequest
 };

package/src/memory.d.ts

@@ -16,19 +16,19 @@ export declare class MemoryCache extends Cache {
     /**
      * Find a cached response for the given request
      */
-    match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
     /**
      * Store a request/response pair in the cache
      */
-    put(request: Request, response: Response): Promise<void>;
+    put(request: RequestInfo | URL, response: Response): Promise<void>;
     /**
      * Delete matching entries from the cache
      */
-    delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
     /**
      * Get all stored requests, optionally filtered by a request pattern
      */
-    keys(request?: Request, options?: CacheQueryOptions): Promise<readonly Request[]>;
+    keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<readonly Request[]>;
     /**
      * Clear all entries from the cache
      */

package/src/memory.js

@@ -1,6 +1,10 @@
 /// <reference types="./memory.d.ts" />
 // src/memory.ts
-import { Cache, generateCacheKey } from "./index.js";
+import {
+  Cache,
+  generateCacheKey,
+  toRequest
+} from "./index.js";
 var MemoryCache = class extends Cache {
   #storage;
   #accessOrder;
@@ -19,6 +23,22 @@ var MemoryCache = class extends Cache {
    * Find a cached response for the given request
    */
   async match(request, options) {
+    if (options?.ignoreSearch) {
+      const filterKey = generateCacheKey(request, options);
+      for (const [key2, entry2] of this.#storage) {
+        if (this.#isExpired(entry2)) {
+          this.#storage.delete(key2);
+          this.#accessOrder.delete(key2);
+          continue;
+        }
+        const entryKey = generateCacheKey(entry2.request, options);
+        if (entryKey === filterKey) {
+          this.#accessOrder.set(key2, ++this.#accessCounter);
+          return entry2.response.clone();
+        }
+      }
+      return void 0;
+    }
     const key = generateCacheKey(request, options);
     const entry = this.#storage.get(key);
     if (!entry) {
@@ -36,11 +56,12 @@ var MemoryCache = class extends Cache {
    * Store a request/response pair in the cache
    */
   async put(request, response) {
-    const key = generateCacheKey(request);
-    if (!this.#isCacheable(response)) {
-      return;
+    const req = toRequest(request);
+    const key = generateCacheKey(req);
+    if (response.bodyUsed) {
+      throw new TypeError("Response body has already been used");
     }
-    const clonedRequest = request.clone();
+    const clonedRequest = req.clone();
     const clonedResponse = response.clone();
     const entry = {
       request: clonedRequest,
@@ -55,6 +76,19 @@ var MemoryCache = class extends Cache {
    * Delete matching entries from the cache
    */
   async delete(request, options) {
+    if (options?.ignoreSearch) {
+      const filterKey = generateCacheKey(request, options);
+      let deleted2 = false;
+      for (const [key2, entry] of this.#storage) {
+        const entryKey = generateCacheKey(entry.request, options);
+        if (entryKey === filterKey) {
+          this.#storage.delete(key2);
+          this.#accessOrder.delete(key2);
+          deleted2 = true;
+        }
+      }
+      return deleted2;
+    }
     const key = generateCacheKey(request, options);
     const deleted = this.#storage.delete(key);
     if (deleted) {
@@ -118,21 +152,6 @@ var MemoryCache = class extends Cache {
     const maxAge = parseInt(maxAgeMatch[1], 10) * 1e3;
     return Date.now() - entry.timestamp > maxAge;
   }
-  /**
-   * Check if a response should be cached
-   */
-  #isCacheable(response) {
-    if (!response.ok) {
-      return false;
-    }
-    const cacheControl = response.headers.get("cache-control");
-    if (cacheControl) {
-      if (cacheControl.includes("no-cache") || cacheControl.includes("no-store")) {
-        return false;
-      }
-    }
-    return true;
-  }
   /**
    * Enforce maximum entry limits using LRU eviction
    */

package/src/postmessage.d.ts

@@ -3,8 +3,6 @@ import { Cache, type CacheQueryOptions } from "./index.js";
  * Configuration options for PostMessageCache
  */
 export interface PostMessageCacheOptions {
-    /** Maximum number of entries to store */
-    maxEntries?: number;
     /** Timeout for cache operations in milliseconds (default: 30000) */
     timeout?: number;
 }
@@ -14,7 +12,7 @@ export interface PostMessageCacheOptions {
  */
 export declare class PostMessageCache extends Cache {
     #private;
-    constructor(name: string, _options?: PostMessageCacheOptions);
+    constructor(name: string, options?: PostMessageCacheOptions);
     match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
     put(request: Request, response: Response): Promise<void>;
     delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;

package/src/postmessage.js

@@ -34,9 +34,11 @@ function handleCacheResponse(message) {
 var globalRequestID = 0;
 var PostMessageCache = class extends Cache {
   #name;
-  constructor(name, _options = {}) {
+  #timeout;
+  constructor(name, options = {}) {
     super();
     this.#name = name;
+    this.#timeout = options.timeout ?? 3e4;
     setupMessageHandler();
   }
   async #sendRequest(type, data) {
@@ -58,7 +60,7 @@ var PostMessageCache = class extends Cache {
           pendingRequestsRegistry.delete(requestID);
           reject(new Error("Cache operation timeout"));
         }
-      }, 3e4);
+      }, this.#timeout);
     });
   }
   async match(request, options) {