@@ -23,7 +26,7 @@
## Features
-- **Tiny:** only ~320 B minzipped
+- **Tiny:** only ~300 B minzipped
- **Flexible:** works for any function that returns a `Promise`
## Install
@@ -35,19 +38,20 @@ $ npm i limit-concur
## Usage
```js
-import got from 'got'
import limitConcur from 'limit-concur'
-const categories = await got(
- `https://api.chucknorris.io/jokes/categories`,
+const categories = await (
+ await fetch(`https://api.chucknorris.io/jokes/categories`)
).json()
+let pendingRequests = 0
const getChuckNorrisJoke = async category => {
- const { value } = await got(`https://api.chucknorris.io/jokes/random`, {
- searchParams: {
- category,
- },
- }).json()
+ console.log(`pending requests: ${++pendingRequests}`)
+ const response = await fetch(
+ `https://api.chucknorris.io/jokes/random?category=${encodeURIComponent(category)}`,
+ )
+ const { value } = await response.json()
+ console.log(`pending requests: ${--pendingRequests}`)
return value
}
@@ -56,6 +60,17 @@ const limitedGetChuckNorrisJoke = limitConcur(4, getChuckNorrisJoke)
// At most 4 requests are pending at any given time!
const jokes = await Promise.all(categories.map(limitedGetChuckNorrisJoke))
console.log(jokes)
+//=> pending requests: 1
+//=> pending requests: 2
+//=> pending requests: 3
+//=> pending requests: 4
+//=> pending requests: 3
+//=> pending requests: 4
+//=> ...
+//=> pending requests: 3
+//=> pending requests: 2
+//=> pending requests: 1
+//=> pending requests: 0
//=> [
// 'Chuck Norris once rode a nine foot grizzly bear through an automatic car wash, instead of taking a shower.',
// "Chuck Norris is actually the front man for Apple. He let's Steve Jobs run the show when he's on a mission. Chuck Norris is always on a mission.",
@@ -65,8 +80,45 @@ console.log(jokes)
// ]
```
-You can get an API equivalent to
-[`p-limit`](https://github.com/sindresorhus/p-limit) like so:
+### Recipes
+
+#### Replacing [`p-map`](https://github.com/sindresorhus/p-map)
+
+```js
+import limitConcur from 'limit-concur'
+
+const urls = [`https://tomeraberba.ch`, `https://lfi.dev`, `https://npmjs.com`]
+
+const mapper = async url => {
+ const { redirected } = await fetch(url, { method: `head` })
+ return redirected
+}
+
+const results = await Promise.all(urls.map(limitConcur(2, mapper)))
+console.log(results)
+//=> [ false, false, true ]
+```
+
+#### Replacing [`p-all`](https://github.com/sindresorhus/p-all)
+
+```js
+import limitConcur from 'limit-concur'
+
+const actions = [
+ () => fetch(`https://tomeraberba.ch`),
+ () => fetch(`https://lfi.dev`),
+ () => checkSomething(),
+ () => doSomethingElse(),
+]
+
+const results = await Promise.all(
+ actions.map(limitConcur(2, action => action())),
+)
+console.log(results)
+//=> [ ..., ..., ... ]
+```
+
+#### Replacing [`p-limit`](https://github.com/sindresorhus/p-limit)
```js
import limitConcur from 'limit-concur'
@@ -79,11 +131,58 @@ const input = [
limit(() => doSomething()),
]
-const result = await Promise.all(input)
-console.log(result)
+const results = await Promise.all(input)
+console.log(results)
//=> [ ..., ..., ... ]
```
+#### Replacing [`p-filter`](https://github.com/sindresorhus/p-filter)
+
+```js
+import limitConcur from 'limit-concur'
+
+const urls = [`https://tomeraberba.ch`, `https://lfi.dev`, `https://npmjs.com`]
+
+const filterer = async url => {
+ const { redirected } = await fetch(url, { method: `head` })
+ return !redirected
+}
+
+const results = await Promise.all(
+ urls.map(limitConcur(2, async url => ({ url, keep: await filterer(url) }))),
+)
+const filtered = results.flatMap(({ url, keep }) => (keep ? [url] : []))
+console.log(filtered)
+//=> [ 'https://tomeraberba.ch', 'https://lfi.dev' ]
+```
+
+#### Replacing [`p-props`](https://github.com/sindresorhus/p-props)
+
+```js
+import limitConcur from 'limit-concur'
+
+const urls = {
+ tomer: `https://tomeraberba.ch`,
+ lfi: `https://lfi.dev`,
+ npm: `https://npmjs.com`,
+}
+
+const mapper = async url => {
+ const { redirected } = await fetch(url, { method: `head` })
+ return redirected
+}
+
+const results = Object.fromEntries(
+ await Promise.all(
+ Object.entries(urls).map(
+ limitConcur(2, async ([name, url]) => [name, await mapper(url)]),
+ ),
+ ),
+)
+console.log(results)
+//=> { tomer: false, lfi: false, npm: true }
+```
+
## Contributing
Stars are always welcome!
@@ -91,11 +190,9 @@ Stars are always welcome!
For bugs and feature requests,
[please create an issue](https://github.com/TomerAberbach/limit-concur/issues/new).
-For pull requests, please read the
-[contributing guidelines](https://github.com/TomerAberbach/limit-concur/blob/main/contributing.md).
-
## License
-[Apache License 2.0](https://github.com/TomerAberbach/limit-concur/blob/main/license)
-
-This is not an official Google product.
+[MIT](https://github.com/TomerAberbach/limit-concur/blob/main/license-mit) ©
+[Tomer Aberbach](https://github.com/TomerAberbach) \
+[Apache 2.0](https://github.com/TomerAberbach/limit-concur/blob/main/license-apache) ©
+[Google](https://github.com/TomerAberbach/limit-concur/blob/main/notice-apache)
diff --git a/src/index.bench.ts b/src/index.bench.ts
new file mode 100644
index 0000000..5bb8542
--- /dev/null
+++ b/src/index.bench.ts
@@ -0,0 +1,9 @@
+import { setTimeout } from 'node:timers/promises'
+import { bench } from 'vitest'
+import limitConcur from './index.ts'
+
+bench(`limitConcur`, async () => {
+ const limited = limitConcur(4, () => setTimeout(20))
+
+ await Promise.all(Array.from({ length: 12 }, () => limited()))
+})
diff --git a/test/index.ts b/src/index.test.ts
similarity index 67%
rename from test/index.ts
rename to src/index.test.ts
index a6f14e2..5f49664 100644
--- a/test/index.ts
+++ b/src/index.test.ts
@@ -1,30 +1,25 @@
-/**
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
import { inspect } from 'node:util'
-import { fc, test } from 'tomer'
-import { createClock } from '@sinonjs/fake-timers'
-import limitConcur from '../src/index.ts'
-
-const clock = createClock(Date.now(), Infinity)
-
-const delay = (timeout: number): Promise
=>
- new Promise(resolve => clock.setTimeout(resolve, timeout))
+import { fc, test } from '@fast-check/vitest'
+import { afterEach, beforeEach, expect, vi } from 'vitest'
+import limitConcur from './index.ts'
+
+beforeEach(() => {
+ vi.useFakeTimers()
+})
+afterEach(() => {
+ vi.restoreAllMocks()
+})
+
+// NOTE: We don't use `setTimeout` from `node:timers/promises` because
+// `useFakeTimers()` doesn't affect it.
+const delay = (ms: number) =>
+ new Promise(resolve => {
+ setTimeout(resolve, ms)
+ })
-const promiseStateSync = (promise: Promise): string => {
+const promiseStateSync = (
+ promise: Promise,
+): `pending` | `rejected` | `fulfilled` => {
const inspectedString = inspect(promise, {
depth: 0,
showProxy: false,
@@ -43,19 +38,23 @@ const promiseStateSync = (promise: Promise): string => {
return `fulfilled`
}
-fc.configureGlobal({ numRuns: 500 })
-
const withAutoAdvancingTimers =
(
fn: (...args: Args) => Promise,
): ((...args: Args) => Promise) =>
async (...args) => {
- void fn(...args)
- await clock.runAllAsync()
+ const promise = fn(...args)
+ while (vi.getTimerCount() > 0) {
+ await vi.runAllTimersAsync()
+ }
+ await promise
}
const asyncFnArb = fc
- .tuple(fc.infiniteStream(fc.integer({ min: 1 })), fc.func(fc.anything()))
+ .tuple(
+ fc.infiniteStream(fc.integer({ min: 1, max: 50 }).map(i => i * 1000)),
+ fc.func(fc.anything()),
+ )
.map(([delays, fn]) =>
Object.assign(
async (...args: unknown[]) => {
@@ -184,30 +183,45 @@ test(
running--
})
- const first = limitedDelay(4)
+ // Queued: {}
+ // Pending: { first: 4000 }
+ // Done: {}
+ const first = limitedDelay(4000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(running).toBe(1)
- await delay(1)
+ // Queued: {}
+ // Pending: { first: 3000 }
+ // Done: {}
+ await delay(1000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(running).toBe(1)
- const second = limitedDelay(2)
+ // Queued: {}
+ // Pending: { first: 3000, second: 2000 }
+ // Done: {}
+ const second = limitedDelay(2000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(promiseStateSync(second)).toBe(`pending`)
expect(running).toBe(2)
- const third = limitedDelay(5)
+ // Queued: {}
+ // Pending: { first: 3000, second: 2000, third: 5000 }
+ // Done: {}
+ const third = limitedDelay(5000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(promiseStateSync(second)).toBe(`pending`)
expect(promiseStateSync(third)).toBe(`pending`)
expect(running).toBe(3)
- const fourth = limitedDelay(5)
+ // Queued: { fourth: 5000 }
+ // Pending: { first: 3000, second: 2000, third: 5000 }
+ // Done: {}
+ const fourth = limitedDelay(5000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(promiseStateSync(second)).toBe(`pending`)
@@ -215,7 +229,10 @@ test(
expect(promiseStateSync(fourth)).toBe(`pending`)
expect(running).toBe(3)
- await delay(2)
+ // Queued: {}
+ // Pending: { first: 1000, third: 3000, fourth: 5000 }
+ // Done: { second: 0 }
+ await delay(2000)
expect(promiseStateSync(first)).toBe(`pending`)
expect(promiseStateSync(second)).toBe(`fulfilled`)
@@ -223,7 +240,10 @@ test(
expect(promiseStateSync(fourth)).toBe(`pending`)
expect(running).toBe(3)
- await delay(2)
+ // Queued: {}
+ // Pending: { third: 1000, fourth: 3000 }
+ // Done: { first: 0, second: 0 }
+ await delay(2000)
expect(promiseStateSync(first)).toBe(`fulfilled`)
expect(promiseStateSync(second)).toBe(`fulfilled`)
@@ -231,7 +251,32 @@ test(
expect(promiseStateSync(fourth)).toBe(`pending`)
expect(running).toBe(2)
- await delay(10)
+ // Queued: {}
+ // Pending: { fourth: 2000 }
+ // Done: { first: 0, second: 0, third: 0 }
+ await delay(1000)
+
+ expect(promiseStateSync(first)).toBe(`fulfilled`)
+ expect(promiseStateSync(second)).toBe(`fulfilled`)
+ expect(promiseStateSync(third)).toBe(`fulfilled`)
+ expect(promiseStateSync(fourth)).toBe(`pending`)
+ expect(running).toBe(1)
+
+ // Queued: {}
+ // Pending: { fourth: 1000 }
+ // Done: { first: 0, second: 0, third: 0 }
+ await delay(1000)
+
+ expect(promiseStateSync(first)).toBe(`fulfilled`)
+ expect(promiseStateSync(second)).toBe(`fulfilled`)
+ expect(promiseStateSync(third)).toBe(`fulfilled`)
+ expect(promiseStateSync(fourth)).toBe(`pending`)
+ expect(running).toBe(1)
+
+ // Queued: {}
+ // Pending: {}
+ // Done: { first: 0, second: 0, third: 0, fourth: 0 }
+ await delay(1000)
expect(promiseStateSync(first)).toBe(`fulfilled`)
expect(promiseStateSync(second)).toBe(`fulfilled`)
diff --git a/src/index.ts b/src/index.ts
index 9a2ddf9..9c69770 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,21 +1,3 @@
-/**
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable typescript/no-explicit-any */
-
const wrapFunction = any>(
from: (...args: any[]) => any,
to: Fn,
@@ -25,12 +7,11 @@ const wrapFunction = any>(
name: { value: from.name },
})
-// eslint-disable-next-line typescript/no-empty-function
const noop = () => {}
/**
- * Return a function equivalent to `fn` except that at most `concurrency` calls
- * to `fn` can run at once at any given time.
+ * Return a function equivalent to {@link fn} except that at most
+ * {@link concurrency} calls to {@link fn} can run at once at any given time.
*/
const limitConcur = Promise>(
concurrency: number,
@@ -59,6 +40,7 @@ const limitConcur = Promise>(
pending.delete(nonThrowingPromise)
})()
+ // eslint-disable-next-line typescript/no-unsafe-return
return promise
}) as Fn)
}
diff --git a/tsconfig.json b/tsconfig.json
index a80fbd1..c792532 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,7 +1,28 @@
{
- "extends": "tomer/tsconfig",
- "include": ["**/*"],
"compilerOptions": {
- "allowImportingTsExtensions": true
- }
+ // Base options
+ "esModuleInterop": true,
+ "skipLibCheck": true,
+ "target": "esnext",
+ "allowJs": true,
+ "resolveJsonModule": true,
+ "moduleDetection": "force",
+ "isolatedModules": true,
+ "verbatimModuleSyntax": true,
+ "incremental": true,
+ "tsBuildInfoFile": "node_modules/.cache/tsconfig.tsbuildinfo",
+ // Strictness
+ "strict": true,
+ "noUncheckedIndexedAccess": true,
+ "noImplicitOverride": true,
+ "noImplicitReturns": true,
+ // Using a bundler
+ "allowImportingTsExtensions": true,
+ "module": "preserve",
+ "moduleResolution": "bundler",
+ "noEmit": true,
+ // Runtime
+ "lib": ["esnext"]
+ },
+ "include": ["**/*"]
}
diff --git a/tsdown.config.ts b/tsdown.config.ts
new file mode 100644
index 0000000..ab9560c
--- /dev/null
+++ b/tsdown.config.ts
@@ -0,0 +1,26 @@
+import { defineConfig } from 'tsdown/config'
+import treeShakeable from 'rollup-plugin-tree-shakeable'
+import terser from '@rollup/plugin-terser'
+
+export default defineConfig([
+ {
+ entry: `src/index.ts`,
+ platform: `neutral`,
+ sourcemap: `inline`,
+ publint: true,
+ plugins: [
+ terser({
+ mangle: {
+ properties: {
+ regex: `^_[^_]+`,
+ },
+ },
+ }),
+ treeShakeable(),
+ ],
+ },
+ {
+ entry: `src/index.ts`,
+ dts: { emitDtsOnly: true },
+ },
+])
diff --git a/types/jest-extended.d.ts b/types/jest-extended.d.ts
new file mode 100644
index 0000000..93d6b8b
--- /dev/null
+++ b/types/jest-extended.d.ts
@@ -0,0 +1,10 @@
+/* eslint-disable typescript/no-empty-object-type */
+/* eslint-disable typescript/consistent-type-definitions */
+import type CustomMatchers from 'jest-extended'
+import 'vitest'
+
+declare module 'vitest' {
+ interface Assertion extends CustomMatchers {}
+ interface AsymmetricMatchersContaining extends CustomMatchers {}
+ interface ExpectStatic extends CustomMatchers {}
+}
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..df0bf77
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+ test: {
+ environment: `jsdom`,
+ setupFiles: [`vitest.setup.ts`],
+ coverage: {
+ include: [`src`],
+ },
+ },
+})
diff --git a/vitest.setup.ts b/vitest.setup.ts
new file mode 100644
index 0000000..5356730
--- /dev/null
+++ b/vitest.setup.ts
@@ -0,0 +1,4 @@
+import { expect } from 'vitest'
+import * as matchers from 'jest-extended'
+
+expect.extend(matchers)
-
+
+