JSPM

In-memory cache implementations with ES6 Map-like API and different eviction strategies

Cache decorators with different strategies.

A simple cache for Ethereum RPC requests extensible with different caching strategies

A caching extension for [Prisma](https://www.prisma.io/), fully compatible with [cache-manager](https://www.npmjs.com/package/cache-manager), predefined uncaching strategies and custom handlers for key generation and uncaching.

A service worker helper library that implements various runtime caching strategies.

Cache manager for nodejs with support different cache strategies

Generate variants of a word following different strategies that are commonly used in order to create a password. This project does not aims to produce an exaustive output but a set of probable values instead. Some of the strategies used to generate are: c

NestJS cache strategies library

workbee service worker strategies

An LRU cache of weak references

Next.js self-hosting simplified.

Memoize promise-returning & async functions

A simple, fast, and flexible cache library for Deno and JavaScript, supporting LRU, LFU, FIFO, and EXPIRE strategies. Works great with TypeScript and is published on jsr.io.

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

Enhance Reselect selectors with deeper memoization and cache management

A cache module equips with rich cache strategies

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

Cache Manager for Node.js

Import a module while bypassing the cache

Simple key-value storage with support for multiple backends

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

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

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

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

Next.js self-hosting simplified.

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.

Memoize functions results using an lru-cache.

Cache requires to be lazy-loaded when needed.

Curated collection of data structures for the JavaScript/TypeScript.

Wraps a transform and provides caching

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

Function memoization with configurable caching and support for async functions

LRU Queue

mdast utility to find definition nodes in a tree

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

React Hooks library for remote data fetching

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

Composable reactive caching with efficient invalidation.

A fully-featured caching GraphQL client.

Memoize/cache function results

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

An abstract object cache interface

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

LRU and FIFO caches for Client or Server

The shared core for the highly customizable and versatile GraphQL client

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

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.

Middleware to destroy caching

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

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.

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.

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

Simple config handling for your app or module

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

Determine XDG Base Directory paths (OS/platform portable)

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

Make synchronous web requests

Clear a module from the cache

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

Multi-strategy object caching service

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

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

broccoli filter but with a persistent cache

Redis storage adapter for Keyv

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

Async disk cache

Reuse typed arrays

sync disk cache

A highly customizable and versatile GraphQL client for React

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

Simple and extensible caching module supporting decorators

A collection of personal utilities to live a happier life

Blazing fast memoization based on all parameters passed

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

Koa ETag support middleware

Cache for Fjell

Simple and Maintained fast NodeJS internal caching

Finds the common standard cache directory

🚩 FastImage, performant React Native image component.

Hard cache the source of modules in webpack.

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.

Cache interceptor for axios

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

Simple, filesystem-backed memoisation cache.

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

Memcache storage adapter for Keyv

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

Conditional GET support for koa

redis-backed LRU cache

Simplifying the use of mocks with Node.js

Unabashedly-barebones memoization library with an aim toward speed

Require extension that allows for caching/precompiling

Create a hash for file revving

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

Valkey storage adapter for Keyv

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

Get the global cache directory

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

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

SQLite storage adapter for Keyv

Polyfill for RFC 566: @cached

A cache for a single user

Actions cache lib

Create a revved file path

🚩 FastImage, performant React Native image component.

In memory cache lru cache with ttl support.

Wipes webpack cache in a controled way.

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

Wipes node.js cache in a controlled way.

A utility to provide lru memoization for any js function

express middleware for caching your routes

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

bounded-size caches having WeakMap-compatible methods

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

Plugin to share a common Redis connection across Fastify.

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

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

In-memory object cache written in typescript for Node that supports multiple eviction strategies.

Easily persist and load config data. No dependencies.

Caching adapter for axios

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

Helper for memoizing async functions and methods

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

Only pass through changed files

Find the proper cache directory based on operating system

Replicates indexed directories using hard links, copies, or cloning

Remote caching for @nrwl/nx using S3 storage

express.js inspired template-engine manager.

Simple API for managing options in JavaScript applications.

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

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

A storage for packages

Static cache for koa

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.

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

Simple in-memory cache for JavaScript

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

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!

Simple key-value storage with support for multiple backends

A humble cache-control parser

Component-wise operations on ndarrays

neat wrapper for various caches

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

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

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.

Infinispan Javascript client

A simple temp file based swap for speeding up operations

fast cached read write of big binary files

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

SSR route, component and data cache for Nuxt

TypeScript utilities for interacting with the Netlify cache

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

TypeScript-based caching decorators

make axios great again

A cache proxy plugin for Gulp

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

LRU Cache for node.js/browser.

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

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

Internal module - vectorized text pooling for gl-vis

A cache for file metadata or file content.

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

The smart data fetching layer for Vue.js

offline-plugin for webpack

An async deduping cache

A highly customizable and versatile GraphQL client for vue

Memoize any function using Keyv as storage backend.

npm util for @file-cache

Middleware for meddling with Cache-Control headers

A high-performance caching solution with multi-layer caching, cache invalidation strategies, and advanced features.

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

node-fetch with caching.

Next.js cache handlers

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

A TypeScript library that wraps objects in a cache-aware Proxy for faster method calls

Turborepo remote cache server

Node module for in memory caching

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

PostgreSQL storage adapter for Keyv

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

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

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

Remote caching for @nrwl/nx using Vercel Remote Cache

URL key-value cache.

Azure client lifecycle management with intelligent caching and authentication

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

Helper for memoizing synchronous functions and methods

Memoize promise-returning & async functions

Redis adapter for catbox

Memory object adapter for catbox

Amazon DAX Client for JavaScript

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.

A link caching plugin for the amqp10 module

Better memcache for node

Clears your NPX cache.

A highly customizable and versatile GraphQL client for Svelte

A Semantic cache built on top of Upstash Vector DB

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 simple caching layer for fetch requests — supports memory, browser (localStorage), and Node.js (filesystem) adapters with smart strategies.

A plugin for Fastify to enable management of cache control headers

Simple and extensible caching module supporting decorators

Require extension that allows for caching/precompiling

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

A diagnostic tool for rush build cache

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

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

Enhanced fetch API with cache strategy, retry pattern, timeout, helper methods and enhanced types.

Create a lazily evaluated value

Arcjet cache interface and implementations

A promise-based cache package for Nodejs using IORedis

LRU Cache

Extends lru-cache to add file system support

Support to control cache behaviour for NextJS applications.

Adapter for using node-cache with type-cacheable

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

Memory storage module for node-ts-cache

The cache of Places found by 🐊Putout

Adapter for using ioredis with type-cacheable

Reusable Cache Service and strategies

memoize the last result, in async way

MongoDB storage adapter for Keyv

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

Bust static assets from the cache using content hashing

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