open-index/open-npm huggingface dataset:
npm package: @qim3d/volume-explorer
Description: QIM Center volume explorer based on vol-e core.
Author: Daniel Toloudis
Latest version: 1.2.1

# QIM Volume Explorer

The QIM Volume Explorer is a data exploration tool for 3D image analysis developed by the [QIM Center](https://qim.dk/).

It is implemented on top of the [vole-core library](https://github.com/allen-cell-animated/vole-core), made by the [Allen Institute for Cell Science](https://www.allencell.org/).

## Installation

Install globally to get the `volume-explorer` command on your `PATH`:

`npm install -g @qim3d/volume-explorer`

`volume-explorer`

You can also run it without a global install:

`npx @qim3d/volume-explorer`

To open a dataset directly:

`volume-explorer https://platform.qim.dk/qim-public/escargot/escargot.zarr`

or

`volume-explorer --src https://platform.qim.dk/qim-public/escargot/escargot.zarr`

The published package now ships a production Vite build, including the worker and shader bundles used for volumetric rendering.

## Development

`git clone git@github.com:qim-center/vole-core.git`

`npm install`

`npm run dev`

For a production-style local run that uses the packaged CLI and built assets:

`npm start`

## Features
- Volumetric data exploration
- Load OME-Zarr, OME-Tiff files from URL
- Intensity histogram, opacity
- Colour pickers
- Area of interest cropping
- OME-Zarr scale level selection

![Landing](https://github.com/qim-center/vole-core/blob/mvp/docs/screenshots/qim-ve-landing.png)
![High def](https://github.com/qim-center/vole-core/blob/mvp/docs/screenshots/qim-ve-high-def.png)

### Advanced

There are two hidden menus for advanced users, accessible by pressing `Ctrl + Alt + 1` and `Ctrl + Alt + 2`.

Advanced menus
![Advanced menus](https://github.com/qim-center/vole-core/blob/mvp/docs/screenshots/qim-ve-advanced-menus.png)
npm package: @qima.mkt/rate-limiter
Description: A client-side rate limiter.
Author: QIMA, Zach Broniszewski
Latest version: 1.0.0

# Rate Limiter

A client-side rate limiter that implements the fixed window algorithm. _(Other algorithms soon to be supported)_

## Table of Contents

<!-- toc -->

- [Problem](#problem)
- [Solution](#solution)
- [How to Use](#how-to-use)

<!-- tocstop -->

## Problem

Naturally, we aim to speed up our processes. When some tasks have the ability to execute concurrently or in-parallel,
we wish to take advantage of it. However, in some cases, we are limited to how many of these tasks we can execute
concurrently. E.g.: The API docs for an API that we are integrating states "up to 10 requests per second" are supported.
How will we ensure this while benefiting from concurrent task execution?

## Solution

A client-side rate limiter solves this problem. We define its limits and feed it our tasks. It can then handle concurrent
task execution while abiding by the limits we set in place. Other open source rate limiters, such as
[limiter](https://www.npmjs.com/package/limiter) either do not support both max concurrency control _and_ time-based rate
limiting, or they do not support all rate limiting algorithms. The goal of this library is to eventually support all
rate limiting algorithms, along with max concurrency control. (E.g. 10 tasks per second, but only 2 tasks at any given time).
Some APIs place limits on both tasks per interval _and_ concurrent tasks, which is why this is necessary. One example is the
[SmartRecruiters API](https://developers.smartrecruiters.com/docs/rate-limiting):

> For most endpoints, SmartAPIs allow up to 10 requests per second... [and] up to 8 concurrent requests.

## How to Use

```javascript
import RateLimiter from 'rate-limiter';

const rateLimiter = new RateLimiter({
  interval: 'second',
  maxPerInterval: 10,
  maxConcurrency: 10
});

// fake async task that takes 1 second
const makeAsyncTask = () => {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, 1000);
  });
};

// add 10 tasks to the rate limiter
const tasks = [];
for (let i = 0; i < 10; i++) {
  tasks.push(rateLimiter.add(makeAsyncTask));
}

// check results of task execution
const results = await Promise.allSettled(tasks);
console.log(results);
// [
//   { status: 'fulfilled', value: 'success' },
//   { status: 'fulfilled', value: 'success' },
//   { status: 'fulfilled', value: 'success' },
//   { status: 'rejected', reason: Error: some error message }
// ]
```