layercache 2.0.0 → 2.1.0

package/dist/edge.cjs

@@ -108,6 +108,9 @@ var MemoryLayer = class {
   onEvict;
   entries = /* @__PURE__ */ new Map();
   cleanupTimer;
+  /**
+   * Creates an in-memory cache layer.
+   */
   constructor(options = {}) {
     this.name = options.name ?? "memory";
     this.defaultTtl = options.ttl;
@@ -121,10 +124,16 @@ var MemoryLayer = class {
       this.cleanupTimer.unref?.();
     }
   }
+  /**
+   * Reads and unwraps a fresh value from memory.
+   */
   async get(key) {
     const value = await this.getEntry(key);
     return unwrapStoredValue(value);
   }
+  /**
+   * Reads the raw stored value or envelope from memory.
+   */
   async getEntry(key) {
     const entry = this.entries.get(key);
     if (!entry) {
@@ -143,12 +152,21 @@ var MemoryLayer = class {
     }
     return entry.value;
   }
+  /**
+   * Reads many raw entries from memory.
+   */
   async getMany(keys) {
     return Promise.all(keys.map((key) => this.getEntry(key)));
   }
+  /**
+   * Writes many entries to memory.
+   */
   async setMany(entries) {
     await Promise.all(entries.map((entry) => this.set(entry.key, entry.value, entry.ttl)));
   }
+  /**
+   * Stores a value in memory using the provided TTL or layer default TTL.
+   */
   async set(key, value, ttl = this.defaultTtl) {
     this.entries.delete(key);
     this.entries.set(key, {
@@ -161,6 +179,9 @@ var MemoryLayer = class {
       this.evict();
     }
   }
+  /**
+   * Returns true when the key exists and has not expired.
+   */
   async has(key) {
     const entry = this.entries.get(key);
     if (!entry) {
@@ -172,6 +193,9 @@ var MemoryLayer = class {
     }
     return true;
   }
+  /**
+   * Returns remaining TTL in milliseconds, or null when absent or non-expiring.
+   */
   async ttl(key) {
     const entry = this.entries.get(key);
     if (!entry) {
@@ -186,40 +210,67 @@ var MemoryLayer = class {
     }
     return Math.max(0, Math.ceil(entry.expiresAt - Date.now()));
   }
+  /**
+   * Returns the number of currently retained, non-expired entries.
+   */
   async size() {
     this.pruneExpired();
     return this.entries.size;
   }
+  /**
+   * Deletes a key from memory.
+   */
   async delete(key) {
     this.entries.delete(key);
   }
+  /**
+   * Deletes multiple keys from memory.
+   */
   async deleteMany(keys) {
     for (const key of keys) {
       this.entries.delete(key);
     }
   }
+  /**
+   * Removes all entries from memory.
+   */
   async clear() {
     this.entries.clear();
   }
+  /**
+   * Health check hook that always succeeds for the in-process layer.
+   */
   async ping() {
     return true;
   }
+  /**
+   * Stops the cleanup timer, when one is active.
+   */
   async dispose() {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = void 0;
     }
   }
+  /**
+   * Returns all currently retained, non-expired keys.
+   */
   async keys() {
     this.pruneExpired();
     return [...this.entries.keys()];
   }
+  /**
+   * Visits all currently retained, non-expired keys.
+   */
   async forEachKey(visitor) {
     this.pruneExpired();
     for (const key of this.entries.keys()) {
       await visitor(key);
     }
   }
+  /**
+   * Exports memory entries for process-local snapshots.
+   */
   exportState() {
     this.pruneExpired();
     return [...this.entries.entries()].map(([key, entry]) => ({
@@ -228,6 +279,9 @@ var MemoryLayer = class {
       expiresAt: entry.expiresAt
     }));
   }
+  /**
+   * Imports entries previously produced by `exportState()`.
+   */
   importState(entries) {
     for (const entry of entries) {
       if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
@@ -346,10 +400,16 @@ var TagIndex = class {
   constructor(options = {}) {
     this.maxKnownKeys = options.maxKnownKeys ?? 1e5;
   }
+  /**
+   * Records a key as known without changing tag assignments.
+   */
   async touch(key) {
     this.insertKnownKey(key);
     this.pruneKnownKeysIfNeeded();
   }
+  /**
+   * Replaces the tags associated with a key and records the key as known.
+   */
   async track(key, tags) {
     this.insertKnownKey(key);
     this.pruneKnownKeysIfNeeded();
@@ -370,17 +430,29 @@ var TagIndex = class {
       this.tagToKeys.set(tag, keys);
     }
   }
+  /**
+   * Removes a key from all tag mappings and known-key tracking.
+   */
   async remove(key) {
     this.removeKey(key);
   }
+  /**
+   * Returns keys currently associated with a tag.
+   */
   async keysForTag(tag) {
     return [...this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()];
   }
+  /**
+   * Visits keys currently associated with a tag.
+   */
   async forEachKeyForTag(tag, visitor) {
     for (const key of this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()) {
       await visitor(key);
     }
   }
+  /**
+   * Returns known keys that start with a prefix.
+   */
   async keysForPrefix(prefix) {
     const node = this.findNode(prefix);
     if (!node) {
@@ -390,6 +462,9 @@ var TagIndex = class {
     this.collectFromNode(node, prefix, matches);
     return matches;
   }
+  /**
+   * Visits known keys that start with a prefix.
+   */
   async forEachKeyForPrefix(prefix, visitor) {
     const node = this.findNode(prefix);
     if (!node) {
@@ -397,20 +472,32 @@ var TagIndex = class {
     }
     await this.visitFromNode(node, prefix, visitor);
   }
+  /**
+   * Returns the tags currently associated with a key.
+   */
   async tagsForKey(key) {
     return [...this.keyToTags.get(key) ?? /* @__PURE__ */ new Set()];
   }
+  /**
+   * Returns known keys matching a wildcard pattern.
+   */
   async matchPattern(pattern) {
     const matches = /* @__PURE__ */ new Set();
     this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set(), 0);
     return [...matches];
   }
+  /**
+   * Visits known keys matching a wildcard pattern.
+   */
   async forEachKeyMatchingPattern(pattern, visitor) {
     const matches = await this.matchPattern(pattern);
     for (const key of matches) {
       await visitor(key);
     }
   }
+  /**
+   * Clears all tag and known-key index state.
+   */
   async clear() {
     this.tagToKeys.clear();
     this.keyToTags.clear();

package/dist/edge.d.cts

@@ -1,2 +1,2 @@
-export { m as CacheContextOptionsContext, o as CacheEntryWriteKind, p as CacheEntryWriteOptions, e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, y as CacheMetricsSnapshot, B as CacheRateLimitOptions, H as CacheTtlPolicy, J as CacheTtlPolicyContext, O as CacheWriteOptions, P as EvictionPolicy, R as MemoryLayer, S as MemoryLayerOptions, T as MemoryLayerSnapshotEntry, U as PatternMatcher, V as TagIndex, W as createHonoCacheMiddleware } from './edge-D2FpRlyS.cjs';
+export { m as CacheContextOptionsContext, o as CacheEntryWriteKind, p as CacheEntryWriteOptions, e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, y as CacheMetricsSnapshot, B as CacheRateLimitOptions, H as CacheTtlPolicy, J as CacheTtlPolicyContext, O as CacheWriteOptions, P as EvictionPolicy, R as MemoryLayer, S as MemoryLayerOptions, T as MemoryLayerSnapshotEntry, U as PatternMatcher, V as TagIndex, W as createHonoCacheMiddleware } from './edge-BCU8D-Yd.cjs';
 import 'node:events';

package/dist/edge.d.ts

@@ -1,2 +1,2 @@
-export { m as CacheContextOptionsContext, o as CacheEntryWriteKind, p as CacheEntryWriteOptions, e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, y as CacheMetricsSnapshot, B as CacheRateLimitOptions, H as CacheTtlPolicy, J as CacheTtlPolicyContext, O as CacheWriteOptions, P as EvictionPolicy, R as MemoryLayer, S as MemoryLayerOptions, T as MemoryLayerSnapshotEntry, U as PatternMatcher, V as TagIndex, W as createHonoCacheMiddleware } from './edge-D2FpRlyS.js';
+export { m as CacheContextOptionsContext, o as CacheEntryWriteKind, p as CacheEntryWriteOptions, e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, y as CacheMetricsSnapshot, B as CacheRateLimitOptions, H as CacheTtlPolicy, J as CacheTtlPolicyContext, O as CacheWriteOptions, P as EvictionPolicy, R as MemoryLayer, S as MemoryLayerOptions, T as MemoryLayerSnapshotEntry, U as PatternMatcher, V as TagIndex, W as createHonoCacheMiddleware } from './edge-BCU8D-Yd.js';
 import 'node:events';

package/dist/edge.js

@@ -2,7 +2,7 @@ import {
   MemoryLayer,
   TagIndex,
   createHonoCacheMiddleware
-} from "./chunk-FFZCC7EQ.js";
+} from "./chunk-IVX6ABFX.js";
 import {
   PatternMatcher
 } from "./chunk-KJDFYE5T.js";