JSPM

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

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

neat wrapper for various caches

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

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

An API wrapper for PokeAPI

Simple axios cache wrapper using node-cache

a streaming wrapper around lru-cache

Thin wrapper around lru-cache with extended functionality.

For managing your client side cache. Tiny wrapper over IndexedDB supporting versioning and max age.

A cluster aware wrapper for node-cache

A wrapper that makes it simple to add caching to any function

> Elegant Console Wrapper

Wrap native HTTP requests with RFC compliant cache support

Lightweight wrapper for accessing npm programmatically (alternative to adding `npm` as a dependency)

Unofficial Musixmatch lyrics API wrapper for Node.js

A wrapper around localforage adding experation times and cache invalidation methods

A localStorage-like wrapper around React Native's AsyncStorage with cache expiration.

Keyv storage adapter wrapper which adds an LRU cache layer

A Node.js wrapper for the Steam Community Market API.

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

🚩 FastImage, performant React Native image component.

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

HTTP response freshness testing

Enhance Reselect selectors with deeper memoization and cache management

persistent wrapper over node-cache for recovery

a wrapper around `browserify` and `watchify` to make incremental builds without the need of the watch mode

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

Zero-dependency minimal package (two functions) to provide better-readable (albeit more verbose) wrapper over JS default `Array.sort()`. Fully typed.

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

a redis wrapper

Simple “Least Recently Used” (LRU) cache

Creates wrapper fns that use yortus async/await internally, to be used with express or sails route handlers / actions

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.

Cache requires to be lazy-loaded when needed.

Curated collection of data structures for the JavaScript/TypeScript.

Memoize functions results using an lru-cache.

Wraps a transform and provides caching

LRU Queue

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

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

mdast utility to find definition nodes in a tree

Cache interceptor for axios

A fully-featured caching GraphQL client.

React Hooks library for remote data fetching

Memoize/cache function results

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.

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

Wraps a function with a caching layer

LRU and FIFO caches for Client or Server

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

The shared core for the highly customizable and versatile GraphQL client

An LRU cache of weak references

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.

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.

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

Wrapper for cache clients for more resilient operations

Make synchronous web requests

Memoize promise-returning & async functions

SSR route, component and data cache for Nuxt

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

Tiny, isomorphic convenience wrapper around the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) aiming to reduce boilerplate, especially when sending and receiving JSON.

Multi-strategy object caching service

A wrapper over @apollo/client that allows you to use persistent cache from local storage, configure TTL, invalidate cache, and use a single configuration for getServerSideProps, SSR, and CSR

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

Wrapper over the ngcc with cache

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

Async disk cache

sync disk cache

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

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

Blazing fast memoization based on all parameters passed

Koa ETag support middleware

A lightweight IndexedDB wrapper with TTL and hash-based operations.

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

Finds the common standard cache directory

Simple and Maintained fast NodeJS internal caching

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

Simple, filesystem-backed memoisation cache.

A lightweight auto-caching wrapper for fetch() and Axios with multi-storage support (localStorage, sessionStorage, IndexedDB, Redis)

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.

Hard cache the source of modules in webpack.

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.

Simplifying the use of mocks with Node.js

Require extension that allows for caching/precompiling

Conditional GET support for koa

Unabashedly-barebones memoization library with an aim toward speed

redis-backed LRU cache

Create a hash for file revving

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

Cache polyfill for the ServiceWorker

A powerful extension of Keyv that adds tag-based cache invalidation and management capabilities.

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

Wrapper class for redis-value-cache adapted for Trees and Members.\ Provides Search for kind with name, id or shortName for trees.\ Provides Search for members by id, group, location, position or link.\ On updates over Redis pub/sub the values are dropped

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

Simple key-value storage with support for multiple backends, and a consistent interface for NestJS-mod (Wrapper for https://www.npmjs.com/package/keyv)

Get the global cache directory

Valkey storage adapter for Keyv

This project is ment to be used with Microsoft Azure Functions. This simple wrapper makes it easier to work with Azure Functions since common HTTP methods are wrapped to individual function calls within a specfic Azure Function. And in addition a function

A normalized and configurable cache exchange for urql

Storage service with TTL

Require a file without adding it into the require cache

Memoized selectors for Redux and other immutable object derivation

Polyfill for RFC 566: @cached

Next.js self-hosting simplified.

SQLite storage adapter for Keyv

A cache for a single user

Manage your Storage with ease, adding expiration dates through a simple API

Actions cache lib

A wrapper that makes it simple to add caching to any function

A client-side caching wrapper for ioredis utilizing Redis 6+ CLIENT TRACKING feature.

Create a revved file path

🚩 FastImage, performant React Native image component.

Wipes webpack cache in a controled way.

A utility to provide lru memoization for any js function

🚩 FastImage, performant React Native image component.

In memory cache lru cache with ttl support.

Wipes node.js cache in a controlled way.

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

express middleware for caching your routes

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

Caching adapter for axios

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

Plugin to share a common Redis connection across Fastify.

Easily persist and load config data. No dependencies.

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

A wrapper that makes it simple to add caching to any function

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

bounded-size caches having WeakMap-compatible methods

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

🚩 FastImage, performant React Native image component.

Create a CAFS store controller

A Map implementation with expirable items

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

Helper for memoizing async functions and methods

Simple API for managing options in JavaScript applications.

Find the proper cache directory based on operating system

express.js inspired template-engine manager.

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

Only pass through changed files

Replicates indexed directories using hard links, copies, or cloning

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'.

A cache module for nodejs that allows easy wrapping of functions in cache, tiered caches, and a consistent interface for NestJS-mod (Wrapper for https://www.npmjs.com/package/cache-manager)

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

Remote caching for @nrwl/nx using S3 storage

A storage for packages

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

Static cache for koa

Make http Requests without all those sub-dependencies, just http/s with a api wrapper

Simple in-memory cache for JavaScript

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!

A humble cache-control parser

Component-wise operations on ndarrays

Simple key-value storage with support for multiple backends

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

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

A simple temp file based swap for speeding up operations

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.

TypeScript utilities for interacting with the Netlify cache

LRU cache module written in C++

A cache proxy plugin for Gulp

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

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

LRU Cache for node.js/browser.

TypeScript-based caching decorators

make axios great again

fast cached read write of big binary files

Internal module - vectorized text pooling for gl-vis

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

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

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

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

Atelier REST API wrapper

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

Infinispan Javascript client

offline-plugin for webpack

Zero-config MCP server for AI-powered marketing tools. Features automatic setup, standalone mode, Interactive Buyer Persona Generator with bilingual support (EN/PT-BR), and enterprise-grade content analysis with 2025 frameworks.

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

A cache for file metadata or file content.

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

A highly customizable and versatile GraphQL client for vue

Node module for in memory caching

An async deduping cache

The smart data fetching layer for Vue.js

node-fetch with caching.

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

Memoize any function using Keyv as storage backend.

Middleware for meddling with Cache-Control headers

npm util for @file-cache

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

Next.js cache handlers

URL key-value cache.

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

Turborepo remote cache server

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

PostgreSQL storage adapter for Keyv

cache layer for jest-resolve

An abstract object cache interface

watchify/browserify wrapper with some useful preconfigured transforms and cache support, to remember the files that were processed and speed up the bundling time

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.

Remote caching for @nrwl/nx using Vercel Remote Cache

Helper for memoizing synchronous functions and methods

Memory object adapter for catbox

Redis adapter for catbox

A link caching plugin for the amqp10 module

Amazon DAX Client for JavaScript

Better memcache for node

🚩 FastImage, performant React Native image component.

A highly customizable and versatile GraphQL client for Svelte

Clears your NPX cache.

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

A Semantic cache built on top of Upstash Vector DB

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

Caching module for sequelize queries

Require extension that allows for caching/precompiling