modality-kit 0.14.4 → 0.14.5

package/dist/index.js

@@ -5947,6 +5947,48 @@ class LruCache {
     return [...this._values.keys()];
   }
 }
+// src/simple-cache.ts
+class SimpleCache {
+  lruCache;
+  ttlMs;
+  maxSize;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? 300000;
+    this.maxSize = options.maxSize ?? 100;
+    this.lruCache = new LruCache(this.maxSize);
+  }
+  set(key, data, ttlMs) {
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      ttl: ttlMs ?? this.ttlMs
+    };
+    this.lruCache.set(key, entry);
+  }
+  get(key, ignoreTTL) {
+    const entry = this.lruCache.get(key);
+    if (!entry)
+      return null;
+    if (entry.ttl !== undefined && !ignoreTTL) {
+      const age = Date.now() - entry.timestamp;
+      if (age > entry.ttl) {
+        this.lruCache.delete(key);
+        return null;
+      }
+    }
+    return entry.data;
+  }
+  has(key) {
+    return this.lruCache.has(key);
+  }
+  delete(key) {
+    const existed = this.lruCache.delete(key);
+    return existed;
+  }
+  keys() {
+    return this.lruCache.keys();
+  }
+}
 export {
   withErrorHandling,
   loadVersion,
@@ -5959,6 +6001,7 @@ export {
   compressWithLanguageDetection as compressText,
   WebSocketClient,
   exports_schemas_symbol as SymbolTypes,
+  SimpleCache,
   LruCache,
   JSONRPCUtils,
   JSONRPCManager,

package/dist/types/index.d.ts

@@ -23,3 +23,5 @@ export { ERROR_METHOD_NOT_FOUND } from "./jsonrpc-manager";
 export { isTestEnvironment } from "./util_tests/isTestEnvironment";
 export { WebSocketClient } from "./websocket-client";
 export { LruCache } from "./lruCache";
+export { SimpleCache } from "./simple-cache";
+export type { SimpleCacheOptions } from "./simple-cache";

package/dist/types/simple-cache.d.ts

@@ -0,0 +1,48 @@
+/**
+ * SimpleCache - Unified caching utility with TTL and LRU support
+ *
+ * Supports two caching strategies:
+ * - TTL-based: Entries expire after specified time
+ * - LRU: Least Recently Used eviction when size limit reached
+ * - Hybrid: Both TTL and LRU can be enabled together
+ */
+/**
+ * Cache options
+ */
+export interface SimpleCacheOptions {
+    /** TTL in milliseconds. Set to undefined to disable TTL. Default: 300000 (5 minutes) */
+    ttlMs?: number;
+    /** Enable LRU eviction. Default: false */
+    enableLru?: boolean;
+    /** Max cache size for LRU. Default: 100 */
+    maxSize?: number;
+}
+/**
+ * SimpleCache - Generic cache supporting TTL and/or LRU eviction
+ */
+export declare class SimpleCache<T> {
+    private lruCache;
+    private readonly ttlMs;
+    private readonly maxSize;
+    constructor(options?: SimpleCacheOptions);
+    /**
+     * Set cache entry
+     * @param key Cache key
+     * @param data Data to cache
+     * @param ttlMs Optional override for TTL (if undefined, uses instance TTL)
+     */
+    set(key: string, data: T, ttlMs?: number): void;
+    /**
+     * Get cache entry if still valid (not expired and not evicted by LRU)
+     */
+    get(key: string, ignoreTTL?: boolean): T | null;
+    /**
+     * Check if key exists and is valid
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a specific key
+     */
+    delete(key: string): boolean;
+    keys(): string[];
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.14.4",
+  "version": "0.14.5",
   "name": "modality-kit",
   "repository": {
     "type": "git",