@b9g/cache 0.1.3 → 0.1.5

package/README.md

@@ -1,13 +1,13 @@
 # @b9g/cache
 
-Universal Cache API implementation providing CacheStorage and Cache interfaces across all JavaScript runtimes.
+**Universal Cache API for ServiceWorker applications. Provides standard CacheStorage and Cache interfaces across all JavaScript runtimes.**
 
 ## Features
 
-- **Standard APIs**: Implements the Cache and CacheStorage APIs from service workers
-- **Multiple Backends**: Memory, filesystem, Redis, KV store implementations
+- **ServiceWorker Cache API**: Standard `caches` global and Cache interface from ServiceWorker spec
+- **Multiple Backends**: Memory, filesystem, Redis, KV store implementations  
 - **Universal**: Same API works in browsers, Node.js, Bun, and edge platforms
-- **Request/Response**: HTTP-semantic caching with full Request/Response support
+- **Request/Response Caching**: Full HTTP semantics with Request/Response objects
 - **Registry Pattern**: Named cache management with factory registration
 
 ## Installation
@@ -96,7 +96,23 @@ import { Router } from '@b9g/router';
 const router = new Router({ caches });
 ```
 
-## Cache API Reference
+## Exports
+
+### Classes
+
+- `Cache` - Abstract base class for cache implementations
+- `CustomCacheStorage` - CacheStorage implementation with factory registration
+
+### Functions
+
+- `generateCacheKey(request, options?)` - Generate a cache key from a Request
+
+### Types
+
+- `CacheQueryOptions` - Options for cache query operations (ignoreSearch, ignoreMethod, ignoreVary)
+- `CacheFactory` - Factory function type `(name: string) => Cache | Promise<Cache>`
+
+## API Reference
 
 ### Standard Cache Methods
 
@@ -186,13 +202,13 @@ caches.register('api', () => new MemoryCache('api'));
 const router = new Router({ caches });
 
 // Cache-aware middleware
-router.use(async (request, context, next) => {
+router.use(async function* (request, context) {
   if (request.method === 'GET' && context.cache) {
     const cached = await context.cache.match(request);
     if (cached) return cached;
   }
   
-  const response = await next();
+  const response = yield request;
   
   if (request.method === 'GET' && context.cache && response.ok) {
     await context.cache.put(request, response.clone());

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@b9g/cache",
-  "version": "0.1.3",
-  "description": "Universal Cache API implementation",
+  "version": "0.1.5",
+  "description": "Universal Cache API for ServiceWorker applications. Provides standard CacheStorage and Cache interfaces across all JavaScript runtimes.",
   "keywords": [
     "cache",
     "storage",
+    "serviceworker",
+    "cachestorage",
     "web-standards",
-    "universal"
+    "universal",
+    "memory",
+    "filesystem",
+    "shovel"
   ],
   "dependencies": {},
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
+    "@b9g/libuild": "^0.1.18",
     "bun-types": "latest"
   },
   "type": "module",
@@ -21,10 +26,6 @@
       "types": "./src/index.d.ts",
       "import": "./src/index.js"
     },
-    "./cache": {
-      "types": "./src/cache.d.ts",
-      "import": "./src/cache.js"
-    },
     "./memory": {
       "types": "./src/memory.d.ts",
       "import": "./src/memory.js"
@@ -34,18 +35,6 @@
       "import": "./src/postmessage.js"
     },
     "./package.json": "./package.json",
-    "./cache.js": {
-      "types": "./src/cache.d.ts",
-      "import": "./src/cache.js"
-    },
-    "./cache-storage": {
-      "types": "./src/cache-storage.d.ts",
-      "import": "./src/cache-storage.js"
-    },
-    "./cache-storage.js": {
-      "types": "./src/cache-storage.d.ts",
-      "import": "./src/cache-storage.js"
-    },
     "./index": {
       "types": "./src/index.d.ts",
       "import": "./src/index.js"

package/src/index.d.ts

@@ -3,15 +3,113 @@
  *
  * Provides HTTP-aware caching with PostMessage coordination for worker environments
  */
-export { Cache, type CacheQueryOptions, generateCacheKey, cloneResponse } from "./cache.js";
-export { CustomCacheStorage, type CacheFactory } from "./cache-storage.js";
-export { MemoryCache, MemoryCacheManager, type MemoryCacheOptions } from "./memory.js";
-export { PostMessageCache, type PostMessageCacheOptions } from "./postmessage.js";
-import { MemoryCache, type MemoryCacheOptions } from "./memory.js";
 /**
- * Platform adapter factory function
- * Creates a MemoryCache instance with the given configuration
+ * Cache query options for matching requests
+ * Based on the Cache API specification
  */
-export declare function createCache(config?: MemoryCacheOptions & {
-    name?: string;
-}): MemoryCache;
+export interface CacheQueryOptions {
+    /** Ignore the search portion of the request URL */
+    ignoreSearch?: boolean;
+    /** Ignore the request method */
+    ignoreMethod?: boolean;
+    /** Ignore the Vary header */
+    ignoreVary?: boolean;
+    /** 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
+ * concrete implementations to handle the core storage operations
+ */
+export declare abstract class Cache {
+    /**
+     * Returns a Promise that resolves to the response associated with the first matching request
+     */
+    abstract match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
+    /**
+     * Puts a request/response pair into the cache
+     */
+    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: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
+    /**
+     * Returns a Promise that resolves to an array of cache keys (Request objects)
+     */
+    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()
+     */
+    add(request: Request): Promise<void>;
+    /**
+     * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
+     * Shared implementation using add()
+     */
+    addAll(requests: Request[]): Promise<void>;
+    /**
+     * Returns a Promise that resolves to an array of all matching responses
+     * Default implementation using keys() and match() - can be overridden for efficiency
+     */
+    matchAll(request?: Request, options?: CacheQueryOptions): Promise<readonly Response[]>;
+}
+/**
+ * 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: RequestInfo | URL, options?: CacheQueryOptions): string;
+/**
+ * Factory function for creating Cache instances based on cache name
+ */
+export type CacheFactory = (name: string) => Cache | Promise<Cache>;
+/**
+ * CustomCacheStorage implements CacheStorage interface with a configurable factory
+ * The factory function receives the cache name and can return different cache types
+ */
+export declare class CustomCacheStorage {
+    #private;
+    constructor(factory: CacheFactory);
+    /**
+     * Matches a request across all caches
+     */
+    match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    /**
+     * Opens a cache with the given name
+     * Returns existing instance if already opened, otherwise creates a new one
+     */
+    open(name: string): Promise<Cache>;
+    /**
+     * Returns true if a cache with the given name exists (has been opened)
+     */
+    has(name: string): Promise<boolean>;
+    /**
+     * Deletes a cache with the given name
+     */
+    delete(name: string): Promise<boolean>;
+    /**
+     * Returns a list of all opened cache names
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Get statistics about the cache storage
+     */
+    getStats(): {
+        openInstances: number;
+        cacheNames: string[];
+    };
+    /**
+     * Dispose of all cache instances
+     * Calls dispose() on each cache if it exists (e.g., RedisCache needs to close connections)
+     */
+    dispose(): Promise<void>;
+    /**
+     * Handle cache messages from worker threads (PostMessageCache coordination)
+     */
+    handleMessage(worker: any, message: any): Promise<void>;
+}

package/src/index.js

@@ -1,21 +1,198 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { Cache, generateCacheKey, cloneResponse } from "./cache.js";
-import { CustomCacheStorage } from "./cache-storage.js";
-import { MemoryCache, MemoryCacheManager } from "./memory.js";
-import { PostMessageCache } from "./postmessage.js";
-import { MemoryCache as MemoryCache2 } from "./memory.js";
-function createCache(config = {}) {
-  const name = config.name || "default";
-  return new MemoryCache2(name, config);
+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
+   * Shared implementation using fetch() and put()
+   */
+  async add(request) {
+    const response = await fetch(request);
+    if (!response.ok) {
+      throw new TypeError(
+        `Failed to fetch ${request.url}: ${response.status} ${response.statusText}`
+      );
+    }
+    await this.put(request, response);
+  }
+  /**
+   * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
+   * Shared implementation using add()
+   */
+  async addAll(requests) {
+    await Promise.all(requests.map((request) => this.add(request)));
+  }
+  /**
+   * Returns a Promise that resolves to an array of all matching responses
+   * Default implementation using keys() and match() - can be overridden for efficiency
+   */
+  async matchAll(request, options) {
+    const keys = await this.keys(request, options);
+    const responses = [];
+    for (const key of keys) {
+      const response = await this.match(key, options);
+      if (response) {
+        responses.push(response);
+      }
+    }
+    return responses;
+  }
+};
+function generateCacheKey(request, options) {
+  const req = toRequest(request);
+  const url = new URL(req.url);
+  if (options?.ignoreSearch) {
+    url.search = "";
+  }
+  const method = options?.ignoreMethod ? "GET" : req.method;
+  return `${method}:${url.href}`;
+}
+var CustomCacheStorage = class {
+  #instances;
+  #factory;
+  constructor(factory) {
+    this.#instances = /* @__PURE__ */ new Map();
+    this.#factory = factory;
+  }
+  /**
+   * Matches a request across all caches
+   */
+  async match(request, options) {
+    for (const cache of this.#instances.values()) {
+      const response = await cache.match(request, options);
+      if (response) {
+        return response;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Opens a cache with the given name
+   * Returns existing instance if already opened, otherwise creates a new one
+   */
+  async open(name) {
+    const existingInstance = this.#instances.get(name);
+    if (existingInstance) {
+      return existingInstance;
+    }
+    const cache = await this.#factory(name);
+    this.#instances.set(name, cache);
+    return cache;
+  }
+  /**
+   * Returns true if a cache with the given name exists (has been opened)
+   */
+  async has(name) {
+    return this.#instances.has(name);
+  }
+  /**
+   * Deletes a cache with the given name
+   */
+  async delete(name) {
+    const instance = this.#instances.get(name);
+    if (instance) {
+      this.#instances.delete(name);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Returns a list of all opened cache names
+   */
+  async keys() {
+    return Array.from(this.#instances.keys());
+  }
+  /**
+   * Get statistics about the cache storage
+   */
+  getStats() {
+    return {
+      openInstances: this.#instances.size,
+      cacheNames: Array.from(this.#instances.keys())
+    };
+  }
+  /**
+   * Dispose of all cache instances
+   * Calls dispose() on each cache if it exists (e.g., RedisCache needs to close connections)
+   */
+  async dispose() {
+    const disposePromises = [];
+    for (const cache of this.#instances.values()) {
+      if (typeof cache.dispose === "function") {
+        disposePromises.push(cache.dispose());
+      }
+    }
+    await Promise.allSettled(disposePromises);
+    this.#instances.clear();
+  }
+  /**
+   * Handle cache messages from worker threads (PostMessageCache coordination)
+   */
+  async handleMessage(worker, message) {
+    const { type, requestID, cacheName } = message;
+    try {
+      const cache = await this.open(cacheName);
+      let result;
+      switch (type) {
+        case "cache:match": {
+          const req = new Request(message.request.url, message.request);
+          const response = await cache.match(req, message.options);
+          result = response ? {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers),
+            body: await response.text()
+          } : void 0;
+          break;
+        }
+        case "cache:put": {
+          const req = new Request(message.request.url, message.request);
+          const res = new Response(message.response.body, message.response);
+          await cache.put(req, res);
+          result = true;
+          break;
+        }
+        case "cache:delete": {
+          const req = new Request(message.request.url, message.request);
+          result = await cache.delete(req, message.options);
+          break;
+        }
+        case "cache:keys": {
+          const req = message.request ? new Request(message.request.url, message.request) : void 0;
+          const keys = await cache.keys(req, message.options);
+          result = keys.map((r) => ({
+            url: r.url,
+            method: r.method,
+            headers: Object.fromEntries(r.headers.entries())
+          }));
+          break;
+        }
+        case "cache:clear":
+          await cache.clear?.();
+          result = true;
+          break;
+      }
+      worker.postMessage({ type: "cache:response", requestID, result });
+    } catch (error) {
+      worker.postMessage({
+        type: "cache:error",
+        requestID,
+        error: error.message
+      });
+    }
+  }
+};
 export {
   Cache,
   CustomCacheStorage,
-  MemoryCache,
-  MemoryCacheManager,
-  PostMessageCache,
-  cloneResponse,
-  createCache,
-  generateCacheKey
+  generateCacheKey,
+  toRequest
 };

package/src/memory.d.ts

@@ -1,40 +1,34 @@
-import { Cache, type CacheQueryOptions } from "./cache.js";
+import { Cache, type CacheQueryOptions } from "./index.js";
 /**
  * Configuration options for MemoryCache
  */
 export interface MemoryCacheOptions {
     /** Maximum number of entries to store */
     maxEntries?: number;
-    /** Maximum age of entries in milliseconds */
-    maxAge?: number;
 }
 /**
  * In-memory cache implementation using Map for storage
  * Supports LRU eviction and TTL expiration
  */
 export declare class MemoryCache extends Cache {
-    private name;
-    private options;
-    private storage;
-    private accessOrder;
-    private accessCounter;
+    #private;
     constructor(name: string, options?: MemoryCacheOptions);
     /**
      * 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<Request[]>;
+    keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<readonly Request[]>;
     /**
      * Clear all entries from the cache
      */
@@ -46,77 +40,6 @@ export declare class MemoryCache extends Cache {
         name: string;
         size: number;
         maxEntries: number;
-        maxAge: number;
         hitRate: number;
     };
-    /**
-     * Dispose of the cache and clean up resources
-     */
-    dispose(): Promise<void>;
-    /**
-     * Check if a cache entry has expired
-     */
-    private isExpired;
-    /**
-     * Check if a response should be cached
-     */
-    private isCacheable;
-    /**
-     * Enforce maximum entry limits using LRU eviction
-     */
-    private enforceMaxEntries;
-}
-/**
- * Memory Cache Manager for Main Thread
- *
- * Coordinates MemoryCache operations across Worker threads by managing
- * shared MemoryCache instances and handling postMessage requests.
- *
- * Only MemoryCache needs coordination since it stores data in process memory.
- * Other cache types can be used directly by workers without coordination.
- */
-interface WorkerLike {
-    postMessage(value: any): void;
-    on(event: string, listener: (data: any) => void): void;
-}
-interface CacheMessage {
-    type: string;
-    requestId: string;
-    cacheName: string;
-    request?: SerializedRequest;
-    response?: SerializedResponse;
-    options?: any;
-}
-interface SerializedRequest {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    body?: string;
-}
-interface SerializedResponse {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: string;
-}
-export declare class MemoryCacheManager {
-    private memoryCaches;
-    /**
-     * Handle memory cache-related message from a Worker
-     */
-    handleMessage(worker: WorkerLike, message: CacheMessage): Promise<void>;
-    /**
-     * Get or create a MemoryCache instance
-     */
-    private getMemoryCache;
-    private handleMatch;
-    private handlePut;
-    private handleDelete;
-    private handleKeys;
-    private handleClear;
-    /**
-     * Dispose of all memory caches
-     */
-    dispose(): Promise<void>;
 }
-export {};

package/src/memory.js

@@ -3,62 +3,96 @@
 import {
   Cache,
   generateCacheKey,
-  cloneResponse
-} from "./cache.js";
+  toRequest
+} from "./index.js";
 var MemoryCache = class extends Cache {
+  #storage;
+  #accessOrder;
+  #accessCounter;
+  #name;
+  #options;
   constructor(name, options = {}) {
     super();
-    this.name = name;
-    this.options = options;
+    this.#storage = /* @__PURE__ */ new Map();
+    this.#accessOrder = /* @__PURE__ */ new Map();
+    this.#accessCounter = 0;
+    this.#name = name;
+    this.#options = options;
   }
-  storage = /* @__PURE__ */ new Map();
-  accessOrder = /* @__PURE__ */ new Map();
-  // For LRU tracking
-  accessCounter = 0;
   /**
    * 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);
+    const entry = this.#storage.get(key);
     if (!entry) {
       return void 0;
     }
-    if (this.isExpired(entry)) {
-      this.storage.delete(key);
-      this.accessOrder.delete(key);
+    if (this.#isExpired(entry)) {
+      this.#storage.delete(key);
+      this.#accessOrder.delete(key);
       return void 0;
     }
-    this.accessOrder.set(key, ++this.accessCounter);
-    return cloneResponse(entry.response);
+    this.#accessOrder.set(key, ++this.#accessCounter);
+    return entry.response.clone();
   }
   /**
    * 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 clonedResponse = await cloneResponse(response);
+    const clonedRequest = req.clone();
+    const clonedResponse = response.clone();
     const entry = {
       request: clonedRequest,
       response: clonedResponse,
       timestamp: Date.now()
     };
-    this.storage.set(key, entry);
-    this.accessOrder.set(key, ++this.accessCounter);
-    this.enforceMaxEntries();
+    this.#storage.set(key, entry);
+    this.#accessOrder.set(key, ++this.#accessCounter);
+    this.#enforceMaxEntries();
   }
   /**
    * 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);
+    const deleted = this.#storage.delete(key);
     if (deleted) {
-      this.accessOrder.delete(key);
+      this.#accessOrder.delete(key);
     }
     return deleted;
   }
@@ -67,8 +101,8 @@ var MemoryCache = class extends Cache {
    */
   async keys(request, options) {
     const keys = [];
-    for (const [_, entry] of this.storage) {
-      if (this.isExpired(entry)) {
+    for (const [_, entry] of this.#storage) {
+      if (this.#isExpired(entry)) {
         continue;
       }
       if (!request) {
@@ -87,208 +121,55 @@ var MemoryCache = class extends Cache {
    * Clear all entries from the cache
    */
   async clear() {
-    this.storage.clear();
-    this.accessOrder.clear();
-    this.accessCounter = 0;
+    this.#storage.clear();
+    this.#accessOrder.clear();
+    this.#accessCounter = 0;
   }
   /**
    * Get cache statistics
    */
   getStats() {
     return {
-      name: this.name,
-      size: this.storage.size,
-      maxEntries: this.options.maxEntries,
-      maxAge: this.options.maxAge,
+      name: this.#name,
+      size: this.#storage.size,
+      maxEntries: this.#options.maxEntries,
       hitRate: 0
       // Could be implemented with additional tracking
     };
   }
   /**
-   * Dispose of the cache and clean up resources
-   */
-  async dispose() {
-    await this.clear();
-  }
-  /**
-   * Check if a cache entry has expired
+   * Check if a cache entry has expired based on Cache-Control header
    */
-  isExpired(entry) {
-    if (!this.options.maxAge) {
+  #isExpired(entry) {
+    const cacheControl = entry.response.headers.get("cache-control");
+    if (!cacheControl) {
       return false;
     }
-    return Date.now() - entry.timestamp > this.options.maxAge;
-  }
-  /**
-   * Check if a response should be cached
-   */
-  isCacheable(response) {
-    if (!response.ok) {
+    const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+    if (!maxAgeMatch) {
       return false;
     }
-    const cacheControl = response.headers.get("cache-control");
-    if (cacheControl) {
-      if (cacheControl.includes("no-cache") || cacheControl.includes("no-store")) {
-        return false;
-      }
-    }
-    return true;
+    const maxAge = parseInt(maxAgeMatch[1], 10) * 1e3;
+    return Date.now() - entry.timestamp > maxAge;
   }
   /**
    * Enforce maximum entry limits using LRU eviction
    */
-  enforceMaxEntries() {
-    if (!this.options.maxEntries || this.storage.size <= this.options.maxEntries) {
+  #enforceMaxEntries() {
+    if (!this.#options.maxEntries || this.#storage.size <= this.#options.maxEntries) {
       return;
     }
-    const entries = Array.from(this.accessOrder.entries()).sort((a, b) => a[1] - b[1]);
-    const toRemove = this.storage.size - this.options.maxEntries;
+    const entries = Array.from(this.#accessOrder.entries()).sort(
+      (a, b) => a[1] - b[1]
+    );
+    const toRemove = this.#storage.size - this.#options.maxEntries;
     for (let i = 0; i < toRemove; i++) {
       const [key] = entries[i];
-      this.storage.delete(key);
-      this.accessOrder.delete(key);
+      this.#storage.delete(key);
+      this.#accessOrder.delete(key);
     }
   }
 };
-var MemoryCacheManager = class {
-  memoryCaches = /* @__PURE__ */ new Map();
-  /**
-   * Handle memory cache-related message from a Worker
-   */
-  async handleMessage(worker, message) {
-    const { type, requestId } = message;
-    try {
-      let result;
-      switch (type) {
-        case "cache:match":
-          result = await this.handleMatch(message);
-          break;
-        case "cache:put":
-          result = await this.handlePut(message);
-          break;
-        case "cache:delete":
-          result = await this.handleDelete(message);
-          break;
-        case "cache:keys":
-          result = await this.handleKeys(message);
-          break;
-        case "cache:clear":
-          result = await this.handleClear(message);
-          break;
-        default:
-          throw new Error(`Unknown cache operation: ${type}`);
-      }
-      worker.postMessage({
-        type: "cache:response",
-        requestId,
-        result
-      });
-    } catch (error) {
-      worker.postMessage({
-        type: "cache:error",
-        requestId,
-        error: error.message
-      });
-    }
-  }
-  /**
-   * Get or create a MemoryCache instance
-   */
-  getMemoryCache(name, options) {
-    if (!this.memoryCaches.has(name)) {
-      this.memoryCaches.set(name, new MemoryCache(name, options));
-    }
-    return this.memoryCaches.get(name);
-  }
-  async handleMatch(message) {
-    const { cacheName, request, options } = message;
-    if (!request)
-      throw new Error("Request is required for match operation");
-    const cache = this.getMemoryCache(cacheName);
-    const req = new Request(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body: request.body
-    });
-    const response = await cache.match(req, options);
-    if (!response) {
-      return void 0;
-    }
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers),
-      body: await response.text()
-    };
-  }
-  async handlePut(message) {
-    const { cacheName, request, response } = message;
-    if (!request || !response)
-      throw new Error("Request and response are required for put operation");
-    const cache = this.getMemoryCache(cacheName);
-    const req = new Request(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body: request.body
-    });
-    const res = new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-    await cache.put(req, res);
-    return true;
-  }
-  async handleDelete(message) {
-    const { cacheName, request, options } = message;
-    if (!request)
-      throw new Error("Request is required for delete operation");
-    const cache = this.getMemoryCache(cacheName);
-    const req = new Request(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body: request.body
-    });
-    return await cache.delete(req, options);
-  }
-  async handleKeys(message) {
-    const { cacheName, request, options } = message;
-    const cache = this.getMemoryCache(cacheName);
-    let req;
-    if (request) {
-      req = new Request(request.url, {
-        method: request.method,
-        headers: request.headers,
-        body: request.body
-      });
-    }
-    const keys = await cache.keys(req, options);
-    return keys.map((r) => ({
-      url: r.url,
-      method: r.method,
-      headers: Object.fromEntries(r.headers),
-      body: void 0
-      // Keys typically don't need body
-    }));
-  }
-  async handleClear(message) {
-    const { cacheName } = message;
-    const cache = this.getMemoryCache(cacheName);
-    await cache.clear();
-    return true;
-  }
-  /**
-   * Dispose of all memory caches
-   */
-  async dispose() {
-    const disposePromises = Array.from(this.memoryCaches.values()).map(
-      (cache) => cache.dispose()
-    );
-    await Promise.all(disposePromises);
-    this.memoryCaches.clear();
-  }
-};
 export {
-  MemoryCache,
-  MemoryCacheManager
+  MemoryCache
 };

package/src/postmessage.d.ts

@@ -1,29 +1,21 @@
-import { Cache, type CacheQueryOptions } from "./cache.js";
+import { Cache, type CacheQueryOptions } from "./index.js";
 /**
  * Configuration options for PostMessageCache
  */
 export interface PostMessageCacheOptions {
-    /** Maximum number of entries to store */
-    maxEntries?: number;
-    /** Maximum age of entries in milliseconds */
-    maxAge?: number;
+    /** Timeout for cache operations in milliseconds (default: 30000) */
+    timeout?: number;
 }
 /**
  * Worker-side cache that forwards operations to main thread via postMessage
  * Only used for MemoryCache in multi-worker environments
  */
 export declare class PostMessageCache extends Cache {
-    private name;
-    private options;
-    private requestId;
-    private pendingRequests;
+    #private;
     constructor(name: string, options?: PostMessageCacheOptions);
-    private handleResponse;
-    private sendRequest;
     match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
     put(request: Request, response: Response): Promise<void>;
     delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
-    keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
+    keys(request?: Request, options?: CacheQueryOptions): Promise<readonly Request[]>;
     clear(): Promise<void>;
-    dispose(): Promise<void>;
 }

package/src/postmessage.js

@@ -1,60 +1,66 @@
 /// <reference types="./postmessage.d.ts" />
 // src/postmessage.ts
-import { Cache } from "./cache.js";
-var isMainThread = typeof self === "undefined";
-var parentPort = typeof self !== "undefined" ? self : null;
+import { Cache } from "./index.js";
+function getParentPort() {
+  return typeof self !== "undefined" ? self : null;
+}
+var messageHandlerSetup = false;
+var pendingRequestsRegistry = /* @__PURE__ */ new Map();
+function setupMessageHandler() {
+  if (messageHandlerSetup)
+    return;
+  messageHandlerSetup = true;
+  const parentPort = getParentPort();
+  if (parentPort && parentPort.addEventListener) {
+    parentPort.addEventListener("message", (event) => {
+      const message = event.data;
+      if (message.type === "cache:response" || message.type === "cache:error") {
+        handleCacheResponse(message);
+      }
+    });
+  }
+}
+function handleCacheResponse(message) {
+  const pending = pendingRequestsRegistry.get(message.requestID);
+  if (pending) {
+    pendingRequestsRegistry.delete(message.requestID);
+    if (message.type === "cache:error") {
+      pending.reject(new Error(message.error));
+    } else {
+      pending.resolve(message.result);
+    }
+  }
+}
+var globalRequestID = 0;
 var PostMessageCache = class extends Cache {
+  #name;
+  #timeout;
   constructor(name, options = {}) {
     super();
-    this.name = name;
-    this.options = options;
-    if (isMainThread) {
-      throw new Error(
-        "PostMessageCache should only be used in worker threads"
-      );
-    }
-    if (parentPort) {
-      parentPort.on("message", (message) => {
-        if (message.type === "cache:response" || message.type === "cache:error") {
-          this.handleResponse(message);
-        }
-      });
-    }
-  }
-  requestId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
-  handleResponse(message) {
-    const pending = this.pendingRequests.get(message.requestId);
-    if (pending) {
-      this.pendingRequests.delete(message.requestId);
-      if (message.type === "cache:error") {
-        pending.reject(new Error(message.error));
-      } else {
-        pending.resolve(message.result);
-      }
-    }
+    this.#name = name;
+    this.#timeout = options.timeout ?? 3e4;
+    setupMessageHandler();
   }
-  async sendRequest(type, data) {
+  async #sendRequest(type, data) {
+    const parentPort = getParentPort();
     if (!parentPort) {
-      throw new Error(
-        "PostMessageCache can only be used in worker threads"
-      );
+      throw new Error("PostMessageCache can only be used in worker threads");
     }
-    const requestId = ++this.requestId;
+    const requestID = ++globalRequestID;
     return new Promise((resolve, reject) => {
-      this.pendingRequests.set(requestId, { resolve, reject });
+      pendingRequestsRegistry.set(requestID, { resolve, reject });
       parentPort.postMessage({
         type,
-        requestId,
-        cacheName: this.name,
+        requestID,
+        cacheName: this.#name,
         ...data
       });
       setTimeout(() => {
-        if (this.pendingRequests.has(requestId)) {
-          this.pendingRequests.delete(requestId);
+        if (pendingRequestsRegistry.has(requestID)) {
+          pendingRequestsRegistry.delete(requestID);
           reject(new Error("Cache operation timeout"));
         }
-      }, 3e4);
+      }, this.#timeout);
     });
   }
   async match(request, options) {
@@ -64,7 +70,7 @@ var PostMessageCache = class extends Cache {
       headers: Object.fromEntries(request.headers),
       body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
     };
-    const response = await this.sendRequest("cache:match", {
+    const response = await this.#sendRequest("cache:match", {
       request: serializedRequest,
       options
     });
@@ -90,7 +96,7 @@ var PostMessageCache = class extends Cache {
       headers: Object.fromEntries(response.headers),
       body: await response.clone().text()
     };
-    await this.sendRequest("cache:put", {
+    await this.#sendRequest("cache:put", {
       request: serializedRequest,
       response: serializedResponse
     });
@@ -102,7 +108,7 @@ var PostMessageCache = class extends Cache {
       headers: Object.fromEntries(request.headers),
       body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
     };
-    return await this.sendRequest("cache:delete", {
+    return await this.#sendRequest("cache:delete", {
       request: serializedRequest,
       options
     });
@@ -117,7 +123,7 @@ var PostMessageCache = class extends Cache {
         body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
       };
     }
-    const keys = await this.sendRequest("cache:keys", {
+    const keys = await this.#sendRequest("cache:keys", {
       request: serializedRequest,
       options
     });
@@ -130,11 +136,7 @@ var PostMessageCache = class extends Cache {
     );
   }
   async clear() {
-    await this.sendRequest("cache:clear", {});
-  }
-  async dispose() {
-    await this.clear();
-    this.pendingRequests.clear();
+    await this.#sendRequest("cache:clear", {});
   }
 };
 export {

package/src/cache-storage.d.ts

@@ -1,44 +0,0 @@
-import type { Cache } from "./cache.js";
-/**
- * Factory function for creating Cache instances based on cache name
- */
-export type CacheFactory = (name: string) => Cache | Promise<Cache>;
-/**
- * CustomCacheStorage implements CacheStorage interface with a configurable factory
- * The factory function receives the cache name and can return different cache types
- */
-export declare class CustomCacheStorage {
-    private factory;
-    private instances;
-    constructor(factory: CacheFactory);
-    /**
-     * Opens a cache with the given name
-     * Returns existing instance if already opened, otherwise creates a new one
-     */
-    open(name: string): Promise<Cache>;
-    /**
-     * Returns true if a cache with the given name exists (has been opened)
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Deletes a cache with the given name
-     * Disposes of the instance if it exists
-     */
-    delete(name: string): Promise<boolean>;
-    /**
-     * Returns a list of all opened cache names
-     */
-    keys(): Promise<string[]>;
-    /**
-     * Get statistics about the cache storage
-     */
-    getStats(): {
-        openInstances: number;
-        cacheNames: string[];
-    };
-    /**
-     * Dispose of all open cache instances
-     * Useful for cleanup during shutdown
-     */
-    dispose(): Promise<void>;
-}

package/src/cache-storage.js

@@ -1,74 +0,0 @@
-/// <reference types="./cache-storage.d.ts" />
-// src/cache-storage.ts
-var CustomCacheStorage = class {
-  constructor(factory) {
-    this.factory = factory;
-  }
-  instances = /* @__PURE__ */ new Map();
-  /**
-   * Opens a cache with the given name
-   * Returns existing instance if already opened, otherwise creates a new one
-   */
-  async open(name) {
-    const existingInstance = this.instances.get(name);
-    if (existingInstance) {
-      return existingInstance;
-    }
-    const cache = await this.factory(name);
-    this.instances.set(name, cache);
-    return cache;
-  }
-  /**
-   * Returns true if a cache with the given name exists (has been opened)
-   */
-  async has(name) {
-    return this.instances.has(name);
-  }
-  /**
-   * Deletes a cache with the given name
-   * Disposes of the instance if it exists
-   */
-  async delete(name) {
-    const instance = this.instances.get(name);
-    if (instance) {
-      if (instance.dispose) {
-        await instance.dispose();
-      }
-      this.instances.delete(name);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Returns a list of all opened cache names
-   */
-  async keys() {
-    return Array.from(this.instances.keys());
-  }
-  /**
-   * Get statistics about the cache storage
-   */
-  getStats() {
-    return {
-      openInstances: this.instances.size,
-      cacheNames: Array.from(this.instances.keys())
-    };
-  }
-  /**
-   * Dispose of all open cache instances
-   * Useful for cleanup during shutdown
-   */
-  async dispose() {
-    const disposePromises = [];
-    for (const [_name, instance] of this.instances) {
-      if (instance.dispose) {
-        disposePromises.push(instance.dispose());
-      }
-    }
-    await Promise.all(disposePromises);
-    this.instances.clear();
-  }
-};
-export {
-  CustomCacheStorage
-};

package/src/cache.d.ts

@@ -1,66 +0,0 @@
-/**
- * Cache query options for matching requests
- * Based on the Cache API specification
- */
-export interface CacheQueryOptions {
-    /** Ignore the search portion of the request URL */
-    ignoreSearch?: boolean;
-    /** Ignore the request method */
-    ignoreMethod?: boolean;
-    /** Ignore the Vary header */
-    ignoreVary?: boolean;
-    /** Custom cache name for scoped operations */
-    cacheName?: string;
-}
-/**
- * Abstract Cache class implementing the Cache API interface
- * Provides shared implementations for add() and addAll() while requiring
- * concrete implementations to handle the core storage operations
- */
-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>;
-    /**
-     * Puts a request/response pair into the cache
-     */
-    abstract put(request: Request, 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>;
-    /**
-     * Returns a Promise that resolves to an array of cache keys (Request objects)
-     */
-    abstract keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
-    /**
-     * Takes a URL, retrieves it and adds the resulting response object to the cache
-     * Shared implementation using fetch() and put()
-     */
-    add(request: Request): Promise<void>;
-    /**
-     * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
-     * Shared implementation using add()
-     */
-    addAll(requests: Request[]): Promise<void>;
-    /**
-     * Returns a Promise that resolves to an array of all matching responses
-     * Default implementation using keys() and match() - can be overridden for efficiency
-     */
-    matchAll(request?: Request, options?: CacheQueryOptions): Promise<Response[]>;
-    /**
-     * Optional cleanup method for implementations that need resource disposal
-     */
-    dispose?(): Promise<void>;
-}
-/**
- * Generate a cache key from a Request object
- * Normalizes the request for consistent cache key generation
- */
-export declare function generateCacheKey(request: Request, options?: CacheQueryOptions): string;
-/**
- * Clone a Response object for storage
- * Responses can only be consumed once, so we need to clone them for caching
- */
-export declare function cloneResponse(response: Response): Promise<Response>;

package/src/cache.js

@@ -1,55 +0,0 @@
-/// <reference types="./cache.d.ts" />
-// src/cache.ts
-var Cache = class {
-  /**
-   * Takes a URL, retrieves it and adds the resulting response object to the cache
-   * Shared implementation using fetch() and put()
-   */
-  async add(request) {
-    const response = await fetch(request);
-    if (!response.ok) {
-      throw new TypeError(
-        `Failed to fetch ${request.url}: ${response.status} ${response.statusText}`
-      );
-    }
-    await this.put(request, response);
-  }
-  /**
-   * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
-   * Shared implementation using add()
-   */
-  async addAll(requests) {
-    await Promise.all(requests.map((request) => this.add(request)));
-  }
-  /**
-   * Returns a Promise that resolves to an array of all matching responses
-   * Default implementation using keys() and match() - can be overridden for efficiency
-   */
-  async matchAll(request, options) {
-    const keys = await this.keys(request, options);
-    const responses = [];
-    for (const key of keys) {
-      const response = await this.match(key, options);
-      if (response) {
-        responses.push(response);
-      }
-    }
-    return responses;
-  }
-};
-function generateCacheKey(request, options) {
-  const url = new URL(request.url);
-  if (options?.ignoreSearch) {
-    url.search = "";
-  }
-  const method = options?.ignoreMethod ? "GET" : request.method;
-  return `${method}:${url.href}`;
-}
-async function cloneResponse(response) {
-  return response.clone();
-}
-export {
-  Cache,
-  cloneResponse,
-  generateCacheKey
-};