JSPM

Memoize/cache function results

Blazing fast memoization based on all parameters passed

A lightweight, high-performance in-memory cache for Node.js with TTL support, configurable eviction policies (FIFO/LRU), statistics tracking, and zero dependencies.

Very straightforward, event driven web crawler. Features a flexible queue interface and a basic cache mechanism with extensible backend.

A cache object that deletes the least-recently-used items.

Caches dns resolutions made with async dns.resolve instead of default sync dns.lookup, refreshes in background

Comprehensive disk and memory caching solution for Tauri applications. Features dynamic TTL management, intelligent data compression, automatic cleanup, and statistics monitoring. Delivers high-performance data access, optimized storage, and improved user

Import a module while bypassing the cache

Simple key-value storage with support for multiple backends

A simple key/value storage using files to persist the data

A lightweight cache for file metadata, ideal for processes that work on a specific set of files and only need to reprocess files that have changed since the last run

HTTP response freshness testing

Define a lazily evaluated property on an object

Get paths for storing things like data, config, cache, etc

Fast, fault-tolerant, cross-platform, disk-based, data-agnostic, content-addressable cache.

Simple “Least Recently Used” (LRU) cache

Opinionated, caching, retrying fetch client

Wrap native HTTP requests with RFC compliant cache support

Reads and caches the entire contents of a file until it is modified

Simple “Least Recently Used” (LRU) cache

Infinispan Javascript client

Basic cache object for storing key-value pairs.

delay the evaluation of a paramless async function and cache the result

Get XDG Base Directory paths

A memoization library which only remembers the latest invocation

A cache for managing namespaced sub-caches

Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks

Basic object cache with `get`, `set`, `del`, and `has` methods for node.js/javascript projects.

Curated collection of data structures for the JavaScript/TypeScript.

Cache requires to be lazy-loaded when needed.

Memoize functions results using an lru-cache.

LRU Queue

Fast, small, efficient JavaScript memoization lib to memoize JS functions

Wraps a transform and provides caching

The closest you can get to require something with bypassing the require cache

mdast utility to find definition nodes in a tree

A fully-featured caching GraphQL client.

React Hooks library for remote data fetching

This library creates a new Response, given a source Response and a Range header value.

Simple and fast NodeJS internal caching. Node internal in memory cache like memcached.

Composable reactive caching with efficient invalidation.

Cache Manager for Node.js

A super-fast, promise-based cache that reads and writes to the file-system.

The shared core for the highly customizable and versatile GraphQL client

Like a JavaScript Set() but with a TTL for entries

LRU and FIFO caches for Client or Server

Middleware to destroy caching

🔥 An extremely fast and efficient LRU cache for JavaScript with high compatibility (including Browsers) — 6.8KB.

Memoize the results of a call to the RegExp constructor, avoiding repetitious runtime compilation of the same string and options, resulting in surprising performance improvements.

An LRU cache of weak references

Finite key-value map using the Least Recently Used (LRU) algorithm where the most recently used objects are keept in the map while less recently used items are evicted to make room for new ones.

A lightweight, in-memory caching library - like Redis but much simpler. Features TTL support, concurrent request handling, and comprehensive statistics. Perfect for Node.js applications that need fast caching without the complexity of Redis.

Like a JavaScript Set, but with a TTL on entries

decache (Delete Cache) lets you delete modules from node.js require() cache; useful when testing your modules/projects.

Simple config handling for your app or module

Determine XDG Base Directory paths (OS/platform portable)

Determine (XDG-compatible) paths for storing application files (cache, config, data, etc)

A high-performance, lightweight LRU cache. Built for developers who need fast caching without compromising on features.

Very low level wrapper arround http.request/https.request

Memory adapter for catbox

Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input

Clear a module from the cache

Memoize promise-returning & async functions

Make synchronous web requests

node-simple-lru-cache =====================

Multi-strategy object caching service

A simple in-memory cache. put(), get() and del()

A tiny, crazy fast memoization library for the 95% use-case

broccoli filter but with a persistent cache

Redis storage adapter for Keyv

Fork of axios-cached-dns-resolve in CJS and with type safety. Caches dns resolutions made with async dns.resolve instead of default sync dns.lookup, refreshes in background

Sometimes you have to do horrible things, like use the global object to share a singleton. Abstract that away, with this!

Require Node module and immediately remove it from module cache to force loading again next time

Reuse typed arrays

A cache object that deletes the least-recently-used items.

Async disk cache

sync disk cache

A highly customizable and versatile GraphQL client for React

A collection of personal utilities to live a happier life

A memcache client for node using the binary protocol and SASL authentication

Koa ETag support middleware

Enhance Reselect selectors with deeper memoization and cache management

🚩 FastImage, performant React Native image component.

Finds the common standard cache directory

Simple and Maintained fast NodeJS internal caching

Hard cache the source of modules in webpack.

Cache interceptor for axios

A fully featured Memcached API client, supporting both single and clustered Memcached servers through consistent hashing and failover/failure. Memcached is rewrite of nMemcached, which will be deprecated in the near future.

Very low level wrapper arround http.request/https.request

Helper base class for Broccoli plugins that map input files into output files one-to-one

Simple, filesystem-backed memoisation cache.

Memcache storage adapter for Keyv

Conditional GET support for koa

Simplifying the use of mocks with Node.js

A module for serving static files. Does etags, caching, etc.

Unabashedly-barebones memoization library with an aim toward speed

Simplistic node redis cache ready can scale with generic-pool support

redis-backed LRU cache

Require extension that allows for caching/precompiling

Create a hash for file revving

A library for creating standardized query keys, useful for cache management in @tanstack/query

A tiny (215B) and fast Least Recently Used (LRU) cache

Cache polyfill for the ServiceWorker

Valkey storage adapter for Keyv

Get the global cache directory

SQLite storage adapter for Keyv

A normalized and configurable cache exchange for urql

Memoized selectors for Redux and other immutable object derivation

Require a file without adding it into the require cache

Polyfill for RFC 566: @cached

Next.js self-hosting simplified.

A wrapper around inquirer that makes it easy to create and selectively reuse questions.

A cache for a single user

Actions cache lib

Create a revved file path

🚩 FastImage, performant React Native image component.

Wipes webpack cache in a controled way.

Wipes node.js cache in a controlled way.

Static asset revisioning by appending content hash to filenames: unicorn.css => unicorn-d41d8cd98f.css

In memory cache lru cache with ttl support.

A utility to provide lru memoization for any js function

File storage adapter for Keyv, using msgpack to serialize data fast and small.

express middleware for caching your routes

bounded-size caches having WeakMap-compatible methods

Plugin to share a common Redis connection across Fastify.

Light-weight Fetch implementation transparently supporting both HTTP/1(.1) and HTTP/2

A least-recently-used cache in 35 lines of code

Caching adapter for axios

Easily persist and load config data. No dependencies.

A Map implementation with expirable items

An ultra-simplified API response caching middleware for Express/Node using plain-english durations.

Create a CAFS store controller

Efficient and lightweight caching utility for VelosJS — includes in-memory caching, optional persistence, and statistics.

Helper for memoizing async functions and methods

An in-memory redis-compatible implementation written in pure javascript. Part of the [Rarefied Redis Project](http://wilkenstein.github.io/rarefied-redis/).

Find the proper cache directory based on operating system

Only pass through changed files

Webpack loader to transform lazy-cache files into unlazy cached files.

Simple API for managing options in JavaScript applications.

Replicates indexed directories using hard links, copies, or cloning

Static cache for koa

express.js inspired template-engine manager.

Remote caching for @nrwl/nx using S3 storage

base-methods plugin that adds a `config` method for mapping declarative configuration values to other 'base' methods or custom functions.

A storage for packages

Plugin for base-methods that maps built-in methods to CLI args (also supports methods from a few plugins, like 'base-store', 'base-options' and 'base-data'.

Easily register and get helper functions to be passed to any template engine or node.js application. Methods for both sync and async helpers.

Simple in-memory cache for JavaScript

A wrapper around node-fetch that caches the request's promise before resolving.

A humble cache-control parser

Plugin for getting and persisting config values with your base-methods application. Adds a 'store' object that exposes all of the methods from the data-store library. Also now supports sub-stores!

Memoize promise-returning functions. Includes cache expire and prefetch.

Simple key-value storage with support for multiple backends

Cache for Fjell

neat wrapper for various caches

A simple temp file based swap for speeding up operations

Config store for values that are commonly needed by project scaffolders, like Generate or Yeoman.

Component-wise operations on ndarrays

A memoization algorithm in which each function argument represents a new key, creating a trie of caches as defined by the array in your first argument.

fast cached read write of big binary files

Signals for managing, caching and syncing asynchronous and remote data in Angular

LRU Cache for node.js/browser.

SSR route, component and data cache for Nuxt

TypeScript utilities for interacting with the Netlify cache

Multi-tier cache module for Node.js. Redis, Upstash, CloudfareKV, File, in-memory and others drivers

A cache proxy plugin for Gulp

TypeScript-based caching decorators

A utility to lazily calculate and cache values in a react component based on props

Internal module - vectorized text pooling for gl-vis

Create High Level Multi-Language Web Site [Fast and Easy]

make axios great again

An easy-to-use Node.js library for cache management with TTL, LRU eviction, and event system.

offline-plugin for webpack

Hard cache the source of modules in webpack. Patched version fixing the hash bug

Broccoli-filter, implemented ontop of the rebuild api()

Lazily evaluates a getter on an object and caches the returned value

A cache for file metadata or file content.

The smart data fetching layer for Vue.js

A highly customizable and versatile GraphQL client for vue

Memoize any function using Keyv as storage backend.

npm util for @file-cache

An async deduping cache

node-fetch with caching.

Quick Mongo Super is a light-weight and easy-to-use Node.js module written in TypeScript to work with MongoDB.

Remote caching for @nrwl/nx using Vercel Remote Cache

Middleware for meddling with Cache-Control headers

Node module for in memory caching

Immediate put/get for abstract-chunk-store compliant stores

Next.js cache handlers

Reduce requests to backend services by batching calls and caching records.

Convert an 'address:port' string to an array [address:string, port:number]

Turborepo remote cache server

A simple and flexible library that caches HTTP requests in Angular applications

An abstract object cache interface

PostgreSQL storage adapter for Keyv

An implementation to speed up the nodejs `dns.lookup` method by avoiding thread pool and using resolve4/resolve6 with DNS TTL values

URL key-value cache.

In-memory LRU cache for abstract-chunk-store compliant stores

Static asset revisioning by appending content hash to filenames: unicorn.css => unicorn.098f6bcd.css, also re-writes references in each file to new reved name.

Memory object adapter for catbox

Helper for memoizing synchronous functions and methods

Amazon DAX Client for JavaScript

Redis adapter for catbox

A link caching plugin for the amqp10 module

Clears your NPX cache.

Fast, lightweight Open Graph, Twitter Card, and structured data extractor for Node.js with caching and validation

A highly customizable and versatile GraphQL client for Svelte

Better memcache for node

Get cross-platform XDG Base Directories or their equivalents. Works with Linux, Windows (win32), or MacOS (darwin).

Redis storage for Koa session middleware/cache with Sentinel and Cluster support

A diagnostic tool for rush build cache

A plugin for Fastify to enable management of cache control headers

A Semantic cache built on top of Upstash Vector DB

Simple and extensible caching module supporting decorators

Node.js solution for memoizing/caching function results on the file system

Require extension that allows for caching/precompiling

[![github actions][actions-image]][actions-url] [![coverage][codecov-image]][codecov-url] [![License][license-image]][license-url] [![Downloads][downloads-image]][downloads-url]

LRU Cache

Arcjet cache interface and implementations

Flushes the internal node cache, useful (and recommended) when testing apps

Create a lazily evaluated value

Generic cache plugin for saving and restoring files and/or folders between Netlify builds

A lightweight, type-safe, in-memory cache with TTL and multiple eviction policies

A promise-based cache package for Nodejs using IORedis

Extends lru-cache to add file system support

Adapter for using node-cache with type-cacheable

The cache of Places found by 🐊Putout

memoize the last result, in async way

Memory storage module for node-ts-cache

Small and efficient cache provider for Node.JS with In-memory, File, Redis and MongoDB engines

PostCSS plugin to replace output file names with HASH algorithms (md5, sha256, sha512, etc) and string length of your choice - for cache busting

Adapter for using ioredis with type-cacheable

Sessionstorage cache for flipflop adapters

MongoDB storage adapter for Keyv

a mock for the browser cache that can be used in a node environment

Localstorage cache for flipflop adapters

Cache values in your Web Extension and clear them on expiration. Also includes a memoize-like API to cache any function results automatically.

Bust static assets from the cache using content hashing

In-memory caching library for Node.JS and also cache engine for cacheman

File caching library for Node.JS and also cache engine for cacheman

In-memory caching library for Node.JS and also cache engine for cacheman

Caching for flipflop adapters

Small and efficient cache provider for Node.JS with In-memory, Redis and MongoDB engines

In-Memory Cache with O(1) Operations and LRU Purging Strategy

Simple store interfaces & utilities

Middleware for meddling with Cache-Control headers

Memory based simple-store implementation

Redis standalone caching library for Node.JS and also cache engine for Cacheman

A simple async LRU cache supporting O(1) set, get and eviction of old keys

Memoz is an in-memory database that persists on disk. The data model is key-value.