More renames

Author: nicolas-van

modern-async.d.ts

@@ -28,9 +28,9 @@ declare module "delayCancellable" {
     export default delayCancellable;
     function delayCancellable(): [Promise<void>, () => boolean];
 }
-declare module "delay" {
-    export default delay;
-    function delay(): Promise<void>;
+declare module "asyncDelay" {
+    export default asyncDelay;
+    function asyncDelay(): Promise<void>;
 }
 declare module "Delayer" {
     export default Delayer;
@@ -63,54 +63,54 @@ declare module "asyncEvery" {
     function asyncEvery<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<boolean>;
     import Queue from "Queue";
 }
-declare module "toArray" {
-    export default toArray;
-    function toArray<V>(iterable: Iterable<V> | AsyncIterable<V>): Promise<V[]>;
+declare module "iterableToArray" {
+    export default iterableToArray;
+    function iterableToArray<V>(iterable: Iterable<V> | AsyncIterable<V>): Promise<V[]>;
 }
-declare module "mapGenerator" {
-    export default mapGenerator;
-    function mapGenerator<V, M>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<M> | M, queueOrConcurrency?: Queue | number, ordered?: boolean): AsyncIterable<M>;
+declare module "asyncGeneratorMap" {
+    export default asyncGeneratorMap;
+    function asyncGeneratorMap<V, M>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<M> | M, queueOrConcurrency?: Queue | number, ordered?: boolean): AsyncIterable<M>;
     import Queue from "Queue";
 }
-declare module "filterGenerator" {
-    export default filterGenerator;
-    function filterGenerator<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): AsyncIterable<V>;
+declare module "asyncGeneratorFilter" {
+    export default asyncGeneratorFilter;
+    function asyncGeneratorFilter<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): AsyncIterable<V>;
     import Queue from "Queue";
 }
 declare module "asyncFilter" {
     export default asyncFilter;
     function asyncFilter<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<V[]>;
     import Queue from "Queue";
 }
-declare module "find" {
-    export default find;
-    function find<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): Promise<V>;
+declare module "asyncFind" {
+    export default asyncFind;
+    function asyncFind<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): Promise<V>;
     import Queue from "Queue";
 }
-declare module "findIndex" {
-    export default findIndex;
-    function findIndex<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): Promise<number>;
+declare module "asyncFindIndex" {
+    export default asyncFindIndex;
+    function asyncFindIndex<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): Promise<number>;
     import Queue from "Queue";
 }
-declare module "forEach" {
-    export default forEach;
-    function forEach<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<void> | void, queueOrConcurrency?: Queue | number): Promise<void>;
+declare module "asyncForEach" {
+    export default asyncForEach;
+    function asyncForEach<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<void> | void, queueOrConcurrency?: Queue | number): Promise<void>;
     import Queue from "Queue";
 }
-declare module "map" {
-    export default map;
-    function map<V, M>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<M> | M, queueOrConcurrency?: Queue | number): Promise<M[]>;
+declare module "asyncMap" {
+    export default asyncMap;
+    function asyncMap<V, M>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<M> | M, queueOrConcurrency?: Queue | number): Promise<M[]>;
     import Queue from "Queue";
 }
-declare module "reduce" {
-    export default reduce;
-    function reduce<V, A>(iterable: Iterable<V> | AsyncIterable<V>,reducer: (accumulator: A, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<A> | A, initial: A): Promise<A>;
-    function reduce<V>(iterable: Iterable<V> | AsyncIterable<V>, reducer: (accumulator: V, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<V> | V): Promise<V>;
+declare module "asyncReduce" {
+    export default asyncReduce;
+    function asyncReduce<V, A>(iterable: Iterable<V> | AsyncIterable<V>,reducer: (accumulator: A, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<A> | A, initial: A): Promise<A>;
+    function asyncReduce<V>(iterable: Iterable<V> | AsyncIterable<V>, reducer: (accumulator: V, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<V> | V): Promise<V>;
 }
-declare module "reduceRight" {
-    export default reduceRight;
-    function reduceRight<V, A>(iterable: Iterable<V> | AsyncIterable<V>,reducer: (accumulator: A, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<A> | A, initial: A): Promise<A>;
-    function reduceRight<V>(iterable: Iterable<V> | AsyncIterable<V>, reducer: (accumulator: V, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<V> | V): Promise<V>;
+declare module "asyncReduceRight" {
+    export default asyncReduceRight;
+    function asyncReduceRight<V, A>(iterable: Iterable<V> | AsyncIterable<V>,reducer: (accumulator: A, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<A> | A, initial: A): Promise<A>;
+    function asyncReduceRight<V>(iterable: Iterable<V> | AsyncIterable<V>, reducer: (accumulator: V, value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<V> | V): Promise<V>;
 }
 declare module "sleepCancellable" {
     export default sleepCancellable;
@@ -145,9 +145,9 @@ declare module "sleepPrecise" {
     export default sleepPrecise;
     function sleepPrecise(amount: number): Promise<void>;
 }
-declare module "some" {
-    export default some;
-    function some<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<boolean>;
+declare module "asyncSome" {
+    export default asyncSome;
+    function asyncSome<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<boolean>;
     import Queue from "Queue";
 }
 declare module "TimeoutError" {
@@ -174,30 +174,30 @@ declare module "modern-async" {
     export { default as asyncWrap } from "asyncWrap";
     export { default as CancelledError } from "CancelledError";
     export { default as Deferred } from "Deferred";
-    export { default as delay } from "delay";
+    export { default as asyncDelay } from "asyncDelay";
     export { default as delayCancellable } from "delayCancellable";
     export { default as Delayer } from "Delayer";
     export { default as asyncEvery } from "asyncEvery";
     export { default as asyncFilter } from "asyncFilter";
-    export { default as filterGenerator } from "filterGenerator";
-    export { default as find } from "find";
-    export { default as findIndex } from "findIndex";
-    export { default as forEach } from "forEach";
-    export { default as map } from "map";
-    export { default as mapGenerator } from "mapGenerator";
+    export { default as asyncGeneratorFilter } from "asyncGeneratorFilter";
+    export { default as asyncFind } from "asyncFind";
+    export { default as asyncFindIndex } from "asyncFindIndex";
+    export { default as asyncForEach } from "asyncForEach";
+    export { default as asyncMap } from "asyncMap";
+    export { default as asyncGeneratorMap } from "asyncGeneratorMap";
     export { default as Queue } from "Queue";
     export { default as queueMicrotask } from "queueMicrotask";
-    export { default as reduce } from "reduce";
-    export { default as reduceRight } from "reduceRight";
+    export { default as asyncReduce } from "asyncReduce";
+    export { default as asyncReduceRight } from "asyncReduceRight";
     export { default as Scheduler } from "Scheduler";
     export { default as sleep } from "sleep";
     export { default as sleepCancellable } from "sleepCancellable";
     export { default as sleepPrecise } from "sleepPrecise";
     export { default as sleepPreciseCancellable } from "sleepPreciseCancellable";
-    export { default as some } from "some";
+    export { default as asyncSome } from "asyncSome";
     export { default as timeout } from "timeout";
     export { default as TimeoutError } from "TimeoutError";
     export { default as timeoutPrecise } from "timeoutPrecise";
-    export { default as toArray } from "toArray";
+    export { default as iterableToArray } from "iterableToArray";
     export { default as reflectStatus } from "reflectStatus";
 }

src/Delayer.mjs

@@ -1,5 +1,5 @@
 
-import delay from './delay.mjs'
+import asyncDelay from './asyncDelay.mjs'
 import assert from 'nanoassert'
 
 /**
@@ -15,7 +15,7 @@ import assert from 'nanoassert'
  * at the end of every loop. `checkDelay()` will check the amount of time that ellasped since the last time
  * it triggered a new task in the event loop. If the amount of time is below the trigger time it returns
  * an already resolved promise and the remaining computation will be able to continue processing in a
- * microtask. If not it will call the `delay()` function that will retrigger the operation in a later task
+ * microtask. If not it will call the `asyncDelay()` function that will retrigger the operation in a later task
  * of the event loop.
  *
  * @example
@@ -69,14 +69,14 @@ class Delayer {
 
   /**
    * Checks if a delay must be applied according to the internal timer. If that's the case this method
-   * will call `delay()` and return `true`. If not it will do nothing and return `false`.
+   * will call `asyncDelay()` and return `true`. If not it will do nothing and return `false`.
    *
    * @returns {boolean} `true` if a new task was scheduled in the event loop, `false` otherwise.
    */
   async checkDelay () {
     const current = new Date().getTime()
     if (current - this._last >= this.triggerTime) {
-      await delay()
+      await asyncDelay()
       this.reset()
       return true
     } else {

src/Queue.test.mjs

@@ -4,7 +4,7 @@ import Queue from './Queue.mjs'
 import Deferred from './Deferred.mjs'
 import CancelledError from './CancelledError.mjs'
 import { range } from 'itertools'
-import delay from './delay.mjs'
+import asyncDelay from './asyncDelay.mjs'
 
 test('Queue base 1', async () => {
   const queue = new Queue(1)
@@ -565,7 +565,7 @@ test('Queue concurrency 1 priority', async () => {
 })
 
 test('Queue all resolve in micro tasks', async () => {
-  const del = delay()
+  const del = asyncDelay()
   const queue = new Queue(1)
   const ps = []
   ps.push(queue.exec(async () => {}))
@@ -580,7 +580,7 @@ test('Queue all resolve in micro tasks', async () => {
 })
 
 test('Queue infinity all resolve in micro tasks', async () => {
-  const del = delay()
+  const del = asyncDelay()
   const queue = new Queue(Number.POSITIVE_INFINITY)
   const ps = []
   ps.push(queue.exec(async () => {}))

src/delay.mjs renamed to src/asyncDelay.mjs

@@ -8,14 +8,14 @@ import delayCancellable from './delayCancellable.mjs'
  *
  * @returns {Promise<void>} A promise that will be resolved on a later tick of the event loop.
  * @example
- * import { delay } from 'modern-async'
+ * import { asyncDelay } from 'modern-async'
  *
  * console.log('this executes in a tick of the event loop')
- * await delay()
+ * await asyncDelay()
  * console.log('this executes in another tick of the event loop')
  */
-async function delay () {
+async function asyncDelay () {
   return delayCancellable()[0]
 }
 
-export default delay
+export default asyncDelay

src/delay.test.mjs renamed to src/asyncDelay.test.mjs

@@ -1,10 +1,10 @@
 
 import { test, expect } from '@jest/globals'
-import delay from './delay.mjs'
+import asyncDelay from './asyncDelay.mjs'
 
-test('delay', async () => {
+test('asyncDelay', async () => {
   const events = []
-  const p = delay().then(() => {
+  const p = asyncDelay().then(() => {
     events.push('resolved')
   })
   Promise.resolve().then(() => {

src/asyncEvery.mjs

@@ -2,7 +2,7 @@
 import Queue from './Queue.mjs'
 import asyncWrap from './asyncWrap.mjs'
 import assert from 'nanoassert'
-import findIndex from './findIndex.mjs'
+import asyncFindIndex from './asyncFindIndex.mjs'
 
 /**
  * Returns `true` if all elements of an iterable pass a truth test and `false` otherwise.
@@ -45,7 +45,7 @@ import findIndex from './findIndex.mjs'
 async function asyncEvery (iterable, iteratee, queueOrConcurrency = 1) {
   assert(typeof iteratee === 'function', 'iteratee must be a function')
   iteratee = asyncWrap(iteratee)
-  const index = await findIndex(iterable, async (value, index, iterable) => {
+  const index = await asyncFindIndex(iterable, async (value, index, iterable) => {
     return !(await iteratee(value, index, iterable))
   }, queueOrConcurrency, false)
   const result = index === -1

src/asyncEvery.test.mjs

@@ -3,7 +3,7 @@ import { expect, test } from '@jest/globals'
 import asyncEvery from './asyncEvery.mjs'
 import Deferred from './Deferred.mjs'
 import { range } from 'itertools'
-import delay from './delay.mjs'
+import asyncDelay from './asyncDelay.mjs'
 
 // eslint-disable-next-line require-jsdoc
 class TestError extends Error {}
@@ -118,7 +118,7 @@ test('asyncEvery error', async () => {
   } catch (e) {
     expect(e).toBeInstanceOf(TestError)
   }
-  await delay()
+  await asyncDelay()
   expect(callList[0]).toStrictEqual(1)
   expect(callList[1]).toStrictEqual(1)
   expect(callList[2]).toStrictEqual(0)
@@ -188,7 +188,7 @@ test('asyncEvery infinite concurrency error', async () => {
   } catch (e) {
     expect(e).toBeInstanceOf(TestError)
   }
-  await delay()
+  await asyncDelay()
 })
 
 test('asyncEvery concurrency 1 all pass', async () => {
@@ -256,7 +256,7 @@ test('asyncEvery concurrency 1 error', async () => {
   } catch (e) {
     expect(e).toBeInstanceOf(TestError)
   }
-  await delay()
+  await asyncDelay()
   expect(callList[0]).toStrictEqual(1)
   expect(callList[1]).toStrictEqual(1)
   expect(callList[2]).toStrictEqual(0)

src/asyncFilter.mjs

@@ -1,7 +1,7 @@
 
 import Queue from './Queue.mjs'
-import toArray from './toArray.mjs'
-import filterGenerator from './filterGenerator.mjs'
+import iterableToArray from './iterableToArray.mjs'
+import asyncGeneratorFilter from './asyncGeneratorFilter.mjs'
 
 /**
  * Returns an array of all the values in `iterable` which pass an asynchronous truth test.
@@ -37,7 +37,7 @@ import filterGenerator from './filterGenerator.mjs'
  * // total processing time should be ~ 20ms
  */
 async function asyncFilter (iterable, iteratee, queueOrConcurrency = 1) {
-  return await toArray(filterGenerator(iterable, iteratee, queueOrConcurrency))
+  return await iterableToArray(asyncGeneratorFilter(iterable, iteratee, queueOrConcurrency))
 }
 
 export default asyncFilter

src/find.mjs renamed to src/asyncFind.mjs

@@ -1,5 +1,5 @@
 
-import findInternal from './findInternal.mjs'
+import asyncFindInternal from './asyncFindInternal.mjs'
 import Queue from './Queue.mjs'
 
 /**
@@ -27,20 +27,20 @@ import Queue from './Queue.mjs'
  * @returns {Promise<any | undefined>} A promise that will be resolved with the first found value or rejected if one of the
  * `iteratee` calls throws an exception before finding a value. If no value is found it will return `undefined`.
  * @example
- * import { find, sleep } from 'modern-async'
+ * import { asyncFind, sleep } from 'modern-async'
  *
  * const array = [1, 2, 3, 4, 5]
- * const result = await find(array, async (v) => {
+ * const result = await asyncFind(array, async (v) => {
  *   // these calls will be performed in parallel with a maximum of 3
  *   // concurrent calls
  *   await sleep(Math.random() * 10) // waits a random amount of time between 0ms and 10ms
  *   return v % 2 === 1
  * }, 3)
  * console.log(result) // prints 1
  */
-async function find (iterable, iteratee, queueOrConcurrency = 1, ordered = false) {
-  const result = (await findInternal(iterable, iteratee, queueOrConcurrency, ordered))[1]
+async function asyncFind (iterable, iteratee, queueOrConcurrency = 1, ordered = false) {
+  const result = (await asyncFindInternal(iterable, iteratee, queueOrConcurrency, ordered))[1]
   return result
 }
 
-export default find
+export default asyncFind