npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details


  • User packages



Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.


Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2023 – Pkg Stats / Ryan Hefner








❗ This package is no longer being actively maintained. ❗


Batteries included fetching library Fetch your data with ease and give your users a better experience



  • Retries
  • Cache
  • Refresh on interval, focus, online
  • Mutate data


Query without parameters

The most simple query is a parameter without parameters, it's just a wrapper around and Observable. The query method expects a callback method to invoke the query.

import { query } from "rx-query";

characters$ = query("characters", () =>

Query with static parameter

A query that has a static parameter (a value that doesn't change over time), can be written in the same way as a query without parameters.

import { query } from "rx-query";

characters$ = query("character", () =>

An alternative way if to pass the static parameter as the first argument. The query callback will then be invoked with the passed parameter.

import { query } from "rx-query";

characters$ = query("character", 1, (characterId) =>

Query with dynamic parameter

If a parameter can change over time (aka an Observable), it can also be passed as a parameter to query. When the input Observable emits a new value, the callback query will be invoked with the new input value.

character$ = query(
	this.activatedRoute.params.pipe(map((p) => p.characterId)),
	(characterId: number) => this.rickAndMortyService.getCharacter(characterId),

Query status

A query can have the following:

  • loading: when the query is being invoked and hasn't responded yet
  • refreshing: when the query is being invoked, and there's a cached value (the cached value gets refreshed when the query is successful)
  • success: when the query returns a successful response
  • error: when the query threw an error
  • mutating: when a mutation is in progress
  • mutate-error: when a mutation threw an error

In the view layer you will often see a structure like this, with a segment to represent each status:

<ng-container *ngIf="characters$ | async as characters">
	<ng-container [ngSwitch]="characters.status">
		<div *ngSwitchCase="'loading'">Loading ... ({{ characters.retries }})</div>

		<div *ngSwitchCase="'error'">
			Something went wrong ... ({{ characters.retries }})

		<div *ngSwitchDefault>
				<li *ngFor="let character of">
					<a [routerLink]="">{{ }}</a>

Refresh a query

Use refreshQuery to trigger a new fetch from a previously contructed query.
Note that the key and parameters provided to refreshQuery should be exactly the same! The following will refetch the data and update the cache.

import { query, refreshQuery } from "rx-query";

character$ = query("character", 1, (id) =>

// On some event
refreshQuery("character", 1);


export type QueryOutput<QueryResult = unknown> = {
	status: Readonly<
		| "idle"
		| "success"
		| "error"
		| "loading"
		| "refreshing"
		| "mutating"
		| "mutate-error"
	data?: Readonly<QueryResult>;
	error?: Readonly<unknown>;
	retries?: Readonly<number>;
	mutate: (data: QueryResult) => void;


The current status of the query.


The result of the query, or the cached result.


The error object returned by the query. Only available in the error status.


Number of query retries. Is reset every time data is fetched. Available on all statuses.


The mutate method to mutate the current query. This is optimistic, the data of the query will be modified while the request is pending. When the request resolves, the query data will be refreshed with the server data. If the request fails, the original data of the query will be restored.


export type QueryConfig = {
	retries?: number | ((retryAttempt: number, error: unknown) => boolean);
	retryDelay?: number | ((retryAttempt: number) => number);
	refetchInterval?: number | Observable<unknown>;
	refetchOnWindowFocus?: boolean;
	refetchOnReconnect?: boolean;
	staleTime?: number;
	cacheTime?: number;
	mutator?: (data: QueryResult, params: QueryParam) => QueryResult;


The number of retries to retry a query before ending up in the error status. Also accepts a callback method ((retryAttempt: number, error: unknown) => boolean) to give more control to the consumer. When a query is being retried, the status remains in the original (loading or refreshing) status. Example.

Default: 3


	retries: 3,

  // Never retry when 3 attempts has been made already, or when the query is totally broken
	retries: (retryAttempt: number, error: string) =>
		retryAttempt < 3 && !error !== "Totally broken",


The delay in milliseconds before retrying the query. Also accepts a callback method ((retryAttempt: number) => number) to give more control to the consumer. Example.

Default: (n) => (n + 1) * 1000


	retryDelay: 100,

  // Increase the delay with 1 second after every attempt
	retryDelay: (retryAttempt) => retryAttempt * 1000,


Invoke the query in the background every x milliseconds, and emit the new value when the query is resolved. Example.

Default: Infinity


  // every 5 minutes
	refetchInterval: 6000 * 5,


Invoke the query in the background when the window is focused, and emit the new value when the query is resolved. Example.

Default: true


	refetchOnWindowFocus: false,


Invoke the query when the client goes back online.

Default: true


	refetchOnReconnect: false,


Set the cache time (in milliseconds) for a query key. Example.

Default: 30_000 (5 minutes)


	cacheTime: 60_000,


Decides when a query should be refetched when it receives a trigger.

Default: 0


	staleTime: 60_000,


The mutator, is the method that will be invoked when the mutate method is called. It receives the data passed to the mutate method and the current params of the query. Example.

Default: mutator: (data) => data


  mutator: (data, queryOptions) =>
      .post(`/persons/${}`, data)
      // 👇 important to let the request throw in order to rollback
      .pipe(catchError((err) => throwError(err.statusText))),

Config override

To override the defaults for all queries, you can use the setQueryConfig method.

	refetchOnWindowFocus: false,
	retries: 0,
	cacheTime: 60_000,


This library is inspired by: