@wfp99/async-lru-cache 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wang Feng Ping
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+# Async LRU Cache
+
+[![npm version](https://badge.fury.io/js/@wfp99%2Fasync-lru-cache.svg)](https://badge.fury.io/js/@wfp99%2Fasync-lru-cache)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D14.0.0-brightgreen.svg)](https://nodejs.org/)
+
+An asynchronous LRU (Least Recently Used) memory cache that supports asynchronous loading and saving operations while automatically handling concurrent requests.
+
+## Features
+
+- 🚀 **Async Support**: Supports asynchronous loader and saver functions
+- 🔄 **Automatic Merging**: Automatically merges concurrent GET requests for the same key
+- 📝 **Serialized Writes**: Serializes PUT operations for the same key to ensure execution order
+- 🗑️ **LRU Eviction**: Implements LRU algorithm to automatically remove least recently used items
+- 🛡️ **Error Handling**: Comprehensive error handling with automatic cache cleanup on failures
+- 🧹 **Complete Clearing**: Support for clearing all cache entries at once
+
+## Installation
+
+```bash
+npm install @wfp99/async-lru-cache
+```
+
+## Requirements
+
+- Node.js >= 14.0.0
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { AsyncLRUCache } from '@wfp99/async-lru-cache';
+
+// Create a cache with maximum 100 items
+const cache = new AsyncLRUCache({
+    capacity: 100
+});
+
+// Use get method to retrieve data
+const data = await cache.get('user:123', async () => {
+    // Loader function executed on cache miss
+    const response = await fetch('/api/users/123');
+    return response.json();
+});
+
+// Use put method to store data
+await cache.put('user:456', userData, async (key, value) => {
+    // Optional saver function for data persistence
+    await saveToDatabase(key, value);
+});
+```
+
+### Error Handling
+
+```typescript
+try {
+    const data = await cache.get('problematic-key', async () => {
+        throw new Error('Load failed');
+    });
+} catch (error) {
+    console.error('Cache load failed:', error);
+    // Failed items are automatically removed from cache
+}
+```
+
+### Advanced Usage
+
+```typescript
+// Working with database
+const cache = new AsyncLRUCache<string, UserData>({ capacity: 500 });
+
+// Load from database with automatic caching
+const user = await cache.get(`user:${userId}`, async () => {
+    return await database.users.findById(userId);
+});
+
+// Save to cache and database atomically
+await cache.put(`user:${userId}`, updatedUser, async (key, value) => {
+    await database.users.update(userId, value);
+});
+```
+
+### Cache Management
+
+```typescript
+// Manually remove specific cache entry
+cache.invalidate('user:123');
+
+// Clear all cache entries
+cache.clear();
+```
+
+## API Reference
+
+### `AsyncLRUCache<K, V>`
+
+#### Constructor
+
+```typescript
+constructor(option: AsyncLRUCacheOption)
+```
+
+#### `AsyncLRUCacheOption`
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `capacity` | `number` | Yes | Maximum number of items allowed in cache. Must be a positive number. |
+
+#### Methods
+
+##### `get(key: K, loader: () => Promise<V>): Promise<V>`
+
+Retrieves data from cache. If not found, uses the loader to load data.
+
+- **key**: Cache key
+- **loader**: Asynchronous loader function executed on cache miss
+- **Returns**: Promise that resolves to the required data
+
+##### `put(key: K, value: V, saver?: (key: K, value: V) => Promise<void>): Promise<V>`
+
+Puts a value into cache and optionally executes a saver function for persistence.
+
+- **key**: Cache key
+- **value**: Value to cache
+- **saver**: Optional asynchronous saver function
+- **Returns**: Promise that resolves to the latest value after saver operation completes
+
+##### `invalidate(key: K): void`
+
+Invalidates and removes the cache entry for the specified key.
+
+- **key**: Cache key to invalidate
+
+##### `clear(): void`
+
+Clears all cache entries. This method removes all items from cache and manually clears node links to prevent potential memory leaks.
+
+## Concurrency Handling
+
+### GET Request Merging
+
+When multiple concurrent requests fetch the same key, AsyncLRUCache automatically merges these requests, ensuring the loader function executes only once:
+
+```typescript
+// These three concurrent requests will share the same loader execution
+const [data1, data2, data3] = await Promise.all([
+    cache.get('shared-key', loader),
+    cache.get('shared-key', loader),
+    cache.get('shared-key', loader)
+]);
+```
+
+### PUT Operation Serialization
+
+Multiple PUT operations for the same key are serialized to ensure they execute in order:
+
+```typescript
+// These operations will execute sequentially, even if started concurrently
+cache.put('key', 'value1', saver1);
+cache.put('key', 'value2', saver2);
+cache.put('key', 'value3', saver3);
+```
+
+## TypeScript Support
+
+This package is fully written in TypeScript and provides complete type support:
+
+```typescript
+interface User {
+    id: string;
+    name: string;
+    email: string;
+}
+
+const userCache = new AsyncLRUCache<string, User>({
+    capacity: 1000
+});
+
+const user: User = await userCache.get('user:123', async () => {
+    // Loader must return User type
+    return fetchUserFromAPI('123');
+});
+```
+
+## Error Handling
+
+- **Loader Failures**: If loader function throws an exception, corresponding cache entry is automatically removed
+- **Saver Failures**: If saver function fails, cache entry is also removed to ensure data consistency
+- **Operation Chain Errors**: PUT operations ignore previous operation errors, allowing new operations to proceed
+- **Error Logging**: All errors are automatically logged to console for debugging
+
+## Memory Management
+
+AsyncLRUCache provides comprehensive memory management:
+
+- **Automatic Eviction**: Automatically removes least recently used items based on capacity
+- **Manual Cleanup**: `clear()` method thoroughly cleans all node links to prevent memory leaks
+- **Error Cleanup**: Automatically cleans related cache entries when operations fail
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and pull requests are welcome on [GitHub](https://github.com/wfp99/async-lru-cache).
+
+## Author
+
+Wang Feng Ping

package/README.zh-TW.md

@@ -0,0 +1,207 @@
+# Async LRU Cache
+
+一個支援非同步載入和保存操作的 LRU（Least Recently Used）記憶體快取類別，自動處理並發請求。
+
+## 特色
+
+- 🚀 **非同步支援**：支援非同步的載入器（loader）和保存器（saver）函數
+- 🔄 **自動合併**：自動合併相同 key 的並發 GET 請求
+- 📝 **序列化寫入**：序列化同一 key 的 PUT 操作，確保順序執行
+- 🗑️ **LRU 淘汰策略**：實現 LRU 演算法，自動移除最久未使用的項目
+- 🛡️ **錯誤處理**：完善的錯誤處理機制，載入或保存失敗時自動清理快取
+- 🧹 **完整清除**：支援一次性清除所有快取項目
+
+## 安裝
+
+```bash
+npm install @wfp99/async-lru-cache
+```
+
+## 系統需求
+
+- Node.js >= 14.0.0
+
+## 使用方法
+
+### 基本使用
+
+```typescript
+import { AsyncLRUCache } from '@wfp99/async-lru-cache';
+
+// 創建一個最多容納 100 個項目的快取
+const cache = new AsyncLRUCache({
+    capacity: 100
+});
+
+// 使用 get 方法獲取資料
+const data = await cache.get('user:123', async () => {
+    // 快取未命中時執行的載入器函數
+    const response = await fetch('/api/users/123');
+    return response.json();
+});
+
+// 使用 put 方法儲存資料
+await cache.put('user:456', userData, async (key, value) => {
+    // 可選的保存器函數，用於持久化資料
+    await saveToDatabase(key, value);
+});
+```
+
+### 錯誤處理
+
+```typescript
+try {
+    const data = await cache.get('problematic-key', async () => {
+        throw new Error('載入失敗');
+    });
+} catch (error) {
+    console.error('快取載入失敗:', error);
+    // 失敗的項目會自動從快取中移除
+}
+```
+
+### 進階使用
+
+```typescript
+// 與資料庫配合使用
+const cache = new AsyncLRUCache<string, UserData>({ capacity: 500 });
+
+// 從資料庫載入並自動快取
+const user = await cache.get(`user:${userId}`, async () => {
+    return await database.users.findById(userId);
+});
+
+// 同時儲存到快取和資料庫
+await cache.put(`user:${userId}`, updatedUser, async (key, value) => {
+    await database.users.update(userId, value);
+});
+```
+
+### 快取管理
+
+```typescript
+// 手動移除特定快取項目
+cache.invalidate('user:123');
+
+// 清除所有快取項目
+cache.clear();
+```
+
+## API 參考
+
+### `AsyncLRUCache<K, V>`
+
+#### 建構函數
+
+```typescript
+constructor(option: AsyncLRUCacheOption)
+```
+
+#### `AsyncLRUCacheOption`
+
+| 屬性 | 類型 | 必需 | 描述 |
+|-----|------|------|------|
+| `capacity` | `number` | 是 | 快取中允許的最大項目數量，必須為正數 |
+
+#### 方法
+
+##### `get(key: K, loader: () => Promise<V>): Promise<V>`
+
+從快取中獲取資料。如果不存在，使用載入器載入資料。
+
+- **key**: 快取鍵
+- **loader**: 快取未命中時執行的非同步載入函數
+- **回傳**: Promise，解析為所需的資料
+
+##### `put(key: K, value: V, saver?: (key: K, value: V) => Promise<void>): Promise<V>`
+
+將值放入快取中，並可選擇性地執行保存器函數進行持久化。
+
+- **key**: 快取鍵
+- **value**: 要快取的值
+- **saver**: 可選的非同步保存函數
+- **回傳**: Promise，解析為保存操作完成後的最新值
+
+##### `invalidate(key: K): void`
+
+使指定鍵的快取項目失效並移除。
+
+- **key**: 要失效的快取鍵
+
+##### `clear(): void`
+
+清除所有快取項目。此方法會移除快取中的所有項目並手動清理節點連結以避免潛在的記憶體洩漏。
+
+## 並發處理
+
+### GET 請求合併
+
+當多個並發請求獲取相同的 key 時，AsyncLRUCache 會自動合併這些請求，確保載入器函數只執行一次：
+
+```typescript
+// 這三個並發請求會共享同一個載入器執行
+const [data1, data2, data3] = await Promise.all([
+    cache.get('shared-key', loader),
+    cache.get('shared-key', loader),
+    cache.get('shared-key', loader)
+]);
+```
+
+### PUT 操作序列化
+
+對同一 key 的多個 PUT 操作會被序列化，確保它們按順序執行：
+
+```typescript
+// 這些操作會按順序執行，即使它們是並發啟動的
+cache.put('key', 'value1', saver1);
+cache.put('key', 'value2', saver2);
+cache.put('key', 'value3', saver3);
+```
+
+## TypeScript 支援
+
+此套件完全使用 TypeScript 編寫，提供完整的型別支援：
+
+```typescript
+interface User {
+    id: string;
+    name: string;
+    email: string;
+}
+
+const userCache = new AsyncLRUCache<string, User>({
+    capacity: 1000
+});
+
+const user: User = await userCache.get('user:123', async () => {
+    // 載入器必須回傳 User 型別
+    return fetchUserFromAPI('123');
+});
+```
+
+## 錯誤處理機制
+
+- **載入器失敗**：如果載入器函數拋出異常，對應的快取項目會被自動移除
+- **保存器失敗**：如果保存器函數失敗，快取項目也會被移除，確保資料一致性
+- **操作鏈錯誤**：PUT 操作會忽略前一個操作的錯誤，確保新操作能夠繼續進行
+- **錯誤日誌**：所有錯誤都會自動記錄到控制台，便於除錯
+
+## 記憶體管理
+
+AsyncLRUCache 具備完善的記憶體管理機制：
+
+- **自動淘汰**：當快取項目數量超過容量限制時，自動移除最久未使用的項目
+- **手動清理**：`clear()` 方法會徹底清理所有節點連結，防止記憶體洩漏
+- **錯誤清理**：操作失敗時自動清理相關快取項目
+
+## 授權
+
+MIT
+
+## 貢獻
+
+歡迎在 [GitHub](https://github.com/wfp99/async-lru-cache) 上提出問題和發送 Pull Request。
+
+## 作者
+
+Wang Feng Ping

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Asynchronous LRU Cache.
+ * Supports asynchronous load and save operations, and automatically handles concurrent requests.
+ * Uses the LRU strategy to evict the oldest items.
+ *
+ * @module AsyncLRUCache
+ */
+/**
+ * Configuration options for the AsyncLRUCache.
+ */
+export interface AsyncLRUCacheOption {
+    /**
+     * Maximum capacity of the cache, this is the maximum number of items allowed.
+     * Must not be less than 10.
+     */
+    capacity: number;
+}
+/**
+ * Asynchronous LRU Cache class.
+ * - Supports asynchronous loaders for data fetching.
+ * - Supports asynchronous savers for data persistence.
+ * - Automatically merges concurrent requests (get) and serializes writes (put).
+ * - Implements LRU eviction strategy.
+ */
+export declare class AsyncLRUCache<K, V> {
+    /**
+     * Maximum capacity of the cache.
+     */
+    private readonly capacity;
+    /**
+     * Map for storing cache entries. The key is the cache key, and the value is the Node.
+     */
+    private dataMap;
+    /**
+     * Head node of the linked list, pointing to the most recently used item.
+     */
+    private head;
+    /**
+     * Tail node of the linked list, pointing to the least recently used item.
+     */
+    private tail;
+    /**
+     * Creates an instance of AsyncLRUCache with the specified options.
+     * @param option - The configuration options for the cache.
+     * @throws {Error} Throws an error if the provided capacity is less than 10.
+     */
+    constructor(option: AsyncLRUCacheOption);
+    /**
+     * Checks if eviction is needed according to the cache strategy.
+     * When the cache exceeds its capacity, automatically removes the tail (least recently used) node.
+     */
+    private _evictIfNeeded;
+    /**
+     * Moves the specified node to the head of the linked list.
+     * This operation is used to mark a node as most recently used.
+     * @param node - The node to move to the head of the list.
+     */
+    private _moveToHead;
+    /**
+     * Removes a node from the doubly linked list used by the cache.
+     * Updates the previous and next pointers of adjacent nodes to unlink the specified node.
+     * @param node - The node to remove from the list.
+     */
+    private _removeNode;
+    /**
+     * Adds the given node to the head (front) of the doubly linked list.
+     * @param node - The node to add to the head of the list.
+     */
+    private _addToHead;
+    /**
+     * Retrieves data from the cache. If it does not exist, uses the loader to load it.
+     * Automatically merges concurrent requests for the same key.
+     * @param key - Cache key.
+     * @param loader - Asynchronous loader function to execute on cache miss.
+     * @returns A Promise that resolves to the required data.
+     */
+    get(key: K, loader: () => Promise<V>): Promise<V>;
+    /**
+     * Puts a value into the cache, and optionally executes a saver function to persist it.
+     * This method serializes multiple put operations for the same key, ensuring they execute in order.
+     * @param key - Cache key.
+     * @param value - Value to cache.
+     * @param saver - Optional asynchronous save function.
+     * @returns A Promise that resolves to the latest value after the saver operation completes.
+     */
+    put(key: K, value: V, saver?: (key: K, value: V) => Promise<void>): Promise<V>;
+    /**
+     * Invalidates and removes the cache entry associated with the specified key.
+     * @param key - The key of the cache entry to invalidate.
+     */
+    invalidate(key: K): void;
+    /**
+     * Clears the entire cache, removing all entries.
+     */
+    clear(): void;
+}

package/dist/index.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Asynchronous LRU Cache.
+ * Supports asynchronous load and save operations, and automatically handles concurrent requests.
+ * Uses the LRU strategy to evict the oldest items.
+ *
+ * @module AsyncLRUCache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLRUCache = void 0;
+/**
+ * Node of the linked list, where value is a Promise representing the eventual data value.
+ */
+class Node {
+    /**
+     * Creates a new Node instance.
+     * @param key - The key associated with this node.
+     * @param value - A Promise that resolves to the value of this node.
+     */
+    constructor(key, value) {
+        /**
+         * Reference to the next node in the linked list.
+         * This property is `null` if there is no next node.
+         */
+        this.next = null;
+        /**
+         * Reference to the previous node in the linked list.
+         * This property is `null` if there is no previous node.
+         */
+        this.prev = null;
+        this.key = key;
+        this.value = value;
+    }
+}
+/**
+ * Asynchronous LRU Cache class.
+ * - Supports asynchronous loaders for data fetching.
+ * - Supports asynchronous savers for data persistence.
+ * - Automatically merges concurrent requests (get) and serializes writes (put).
+ * - Implements LRU eviction strategy.
+ */
+class AsyncLRUCache {
+    /**
+     * Creates an instance of AsyncLRUCache with the specified options.
+     * @param option - The configuration options for the cache.
+     * @throws {Error} Throws an error if the provided capacity is less than 10.
+     */
+    constructor(option) {
+        /**
+         * Map for storing cache entries. The key is the cache key, and the value is the Node.
+         */
+        this.dataMap = new Map();
+        /**
+         * Head node of the linked list, pointing to the most recently used item.
+         */
+        this.head = null;
+        /**
+         * Tail node of the linked list, pointing to the least recently used item.
+         */
+        this.tail = null;
+        if (option.capacity < 10)
+            throw new Error("Capacity must be at least 10.");
+        this.capacity = option.capacity;
+    }
+    /**
+     * Checks if eviction is needed according to the cache strategy.
+     * When the cache exceeds its capacity, automatically removes the tail (least recently used) node.
+     */
+    _evictIfNeeded() {
+        if (this.dataMap.size > this.capacity) {
+            this.dataMap.delete(this.tail.key);
+            this._removeNode(this.tail);
+        }
+    }
+    /**
+     * Moves the specified node to the head of the linked list.
+     * This operation is used to mark a node as most recently used.
+     * @param node - The node to move to the head of the list.
+     */
+    _moveToHead(node) {
+        if (node === this.head)
+            return;
+        this._removeNode(node);
+        this._addToHead(node);
+    }
+    /**
+     * Removes a node from the doubly linked list used by the cache.
+     * Updates the previous and next pointers of adjacent nodes to unlink the specified node.
+     * @param node - The node to remove from the list.
+     */
+    _removeNode(node) {
+        if (node.prev)
+            node.prev.next = node.next;
+        else
+            this.head = node.next;
+        if (node.next)
+            node.next.prev = node.prev;
+        else
+            this.tail = node.prev;
+    }
+    /**
+     * Adds the given node to the head (front) of the doubly linked list.
+     * @param node - The node to add to the head of the list.
+     */
+    _addToHead(node) {
+        node.prev = null;
+        node.next = this.head;
+        if (this.head)
+            this.head.prev = node;
+        this.head = node;
+        if (!this.tail)
+            this.tail = node;
+    }
+    /**
+     * Retrieves data from the cache. If it does not exist, uses the loader to load it.
+     * Automatically merges concurrent requests for the same key.
+     * @param key - Cache key.
+     * @param loader - Asynchronous loader function to execute on cache miss.
+     * @returns A Promise that resolves to the required data.
+     */
+    get(key, loader) {
+        const node = this.dataMap.get(key);
+        if (node) {
+            this._moveToHead(node);
+            return node.value;
+        }
+        const loadingPromise = loader();
+        const newNode = new Node(key, loadingPromise);
+        this.dataMap.set(key, newNode);
+        this._addToHead(newNode);
+        this._evictIfNeeded();
+        loadingPromise.catch(err => {
+            console.error(`[AsyncLRUCache ERROR] Loader for key ${key} failed. Removing from cache.`, err);
+            if (this.dataMap.get(key) === newNode) {
+                this.dataMap.delete(key);
+                this._removeNode(newNode);
+            }
+        });
+        return loadingPromise;
+    }
+    /**
+     * Puts a value into the cache, and optionally executes a saver function to persist it.
+     * This method serializes multiple put operations for the same key, ensuring they execute in order.
+     * @param key - Cache key.
+     * @param value - Value to cache.
+     * @param saver - Optional asynchronous save function.
+     * @returns A Promise that resolves to the latest value after the saver operation completes.
+     */
+    put(key, value, saver) {
+        const lastPromise = this.dataMap.has(key) ? this.dataMap.get(key).value : Promise.resolve(undefined);
+        const saverPromise = lastPromise.catch((err) => {
+            // Ignore previous operation errors, so the new operation can proceed.
+            console.warn(`[AsyncLRUCache WARN] Previous operation for key ${key} failed. Chaining new PUT operation.`, err.message);
+        })
+            .then(() => {
+            // After the previous operation (success or failure) completes, execute this saver.
+            if (saver)
+                return saver(key, value);
+        })
+            .then(() => {
+            // After saver completes, the final value of this Promise chain is the new value.
+            return value;
+        });
+        let node = this.dataMap.get(key);
+        if (!node) {
+            node = new Node(key, saverPromise);
+            this.dataMap.set(key, node);
+            this._addToHead(node);
+            this._evictIfNeeded();
+        }
+        else {
+            node.value = saverPromise;
+            this._moveToHead(node);
+        }
+        saverPromise.catch(err => {
+            var _a;
+            console.error(`[AsyncLRUCache ERROR] Saver operation for key ${key} failed. Removing from cache.`, err);
+            if (((_a = this.dataMap.get(key)) === null || _a === void 0 ? void 0 : _a.value) === saverPromise) {
+                this.dataMap.delete(key);
+                this._removeNode(node);
+            }
+        });
+        return saverPromise;
+    }
+    /**
+     * Invalidates and removes the cache entry associated with the specified key.
+     * @param key - The key of the cache entry to invalidate.
+     */
+    invalidate(key) {
+        const node = this.dataMap.get(key);
+        if (node) {
+            this._removeNode(node);
+            this.dataMap.delete(key);
+        }
+    }
+    /**
+     * Clears the entire cache, removing all entries.
+     */
+    clear() {
+        this.dataMap.clear();
+        // Manually clear all node links to avoid any potential memory leaks.
+        let node = this.head;
+        while (node !== null) {
+            // Save reference to the next node, as we are about to break the current node's next link.
+            const next = node.next;
+            // Break all internal and external links of the current node and clear data.
+            node.prev = null;
+            node.next = null;
+            node.key = null;
+            node.value = Promise.resolve(undefined);
+            // Move to the next node.
+            node = next;
+        }
+        this.head = null;
+        this.tail = null;
+    }
+}
+exports.AsyncLRUCache = AsyncLRUCache;

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@wfp99/async-lru-cache",
+	"version": "1.0.0",
+	"description": "A simple memory cache using the LRU algorithm and supporting asynchronous data access.",
+	"keywords": [
+		"cache",
+		"LRU",
+		"async",
+		"TypeScript",
+		"node.js"
+	],
+	"license": "MIT",
+	"author": "Wang Feng Ping <wfp@nebuis.com>",
+	"type": "commonjs",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist/",
+		"README.md",
+		"README.zh-TW.md",
+		"LICENSE"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/wfp99/async-lru-cache.git"
+	},
+	"bugs": {
+		"url": "https://github.com/wfp99/async-lru-cache/issues"
+	},
+	"homepage": "https://github.com/wfp99/async-lru-cache#readme",
+	"engines": {
+		"node": ">=14.0.0"
+	},
+	"scripts": {
+		"build": "tsc",
+		"clean": "rm -rf dist",
+		"prepublishOnly": "npm run clean && npm run build",
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"devDependencies": {
+		"@types/node": "^24.0.7",
+		"typescript": "^5.8.3"
+	}
+}