More renames

Author: nicolas-van

modern-async.d.ts

@@ -24,9 +24,9 @@ declare module "Deferred" {
         get reject(): (v: any) => void;
     }
 }
-declare module "delayCancellable" {
-    export default delayCancellable;
-    function delayCancellable(): [Promise<void>, () => boolean];
+declare module "asyncDelayCancellable" {
+    export default asyncDelayCancellable;
+    function asyncDelayCancellable(): [Promise<void>, () => boolean];
 }
 declare module "asyncDelay" {
     export default asyncDelay;
@@ -63,9 +63,9 @@ 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 "iterableToArray" {
-    export default iterableToArray;
-    function iterableToArray<V>(iterable: Iterable<V> | AsyncIterable<V>): Promise<V[]>;
+declare module "asyncIterableToArray" {
+    export default asyncIterableToArray;
+    function asyncIterableToArray<V>(iterable: Iterable<V> | AsyncIterable<V>): Promise<V[]>;
 }
 declare module "asyncGeneratorMap" {
     export default asyncGeneratorMap;
@@ -112,9 +112,9 @@ declare module "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;
-    function sleepCancellable(amount: number): [Promise<void>, () => boolean];
+declare module "asyncSleepCancellable" {
+    export default asyncSleepCancellable;
+    function asyncSleepCancellable(amount: number): [Promise<void>, () => boolean];
 }
 declare module "Scheduler" {
     export default Scheduler;
@@ -133,17 +133,17 @@ declare module "Scheduler" {
         stop(): void;
     }
 }
-declare module "sleep" {
-    export default sleep;
-    function sleep(amount: number): Promise<void>;
+declare module "asyncSleep" {
+    export default asyncSleep;
+    function asyncSleep(amount: number): Promise<void>;
 }
-declare module "sleepPreciseCancellable" {
-    export default sleepPreciseCancellable;
-    function sleepPreciseCancellable(amount: number): [Promise<void>, () => boolean];
+declare module "asyncSleepPreciseCancellable" {
+    export default asyncSleepPreciseCancellable;
+    function asyncSleepPreciseCancellable(amount: number): [Promise<void>, () => boolean];
 }
-declare module "sleepPrecise" {
-    export default sleepPrecise;
-    function sleepPrecise(amount: number): Promise<void>;
+declare module "asyncSleepPrecise" {
+    export default asyncSleepPrecise;
+    function asyncSleepPrecise(amount: number): Promise<void>;
 }
 declare module "asyncSome" {
     export default asyncSome;
@@ -156,17 +156,17 @@ declare module "TimeoutError" {
         constructor(message: string);
     }
 }
-declare module "timeout" {
-    export default timeout;
-    function timeout<T>(fct: () => Promise<T> | T, amount: number): Promise<T>;
+declare module "asyncTimeout" {
+    export default asyncTimeout;
+    function asyncTimeout<T>(fct: () => Promise<T> | T, amount: number): Promise<T>;
 }
-declare module "timeoutPrecise" {
-    export default timeoutPrecise;
-    function timeoutPrecise<T>(fct: () => Promise<T> | T, amount: number): Promise<T>;
+declare module "asyncTimeoutPrecise" {
+    export default asyncTimeoutPrecise;
+    function asyncTimeoutPrecise<T>(fct: () => Promise<T> | T, amount: number): Promise<T>;
 }
-declare module "reflectStatus" {
-    export default reflectStatus;
-    function reflectStatus<T>(fct: () => Promise<T> | T): Promise<PromiseSettledResult<T>>;
+declare module "reflectAsyncStatus" {
+    export default reflectAsyncStatus;
+    function reflectAsyncStatus<T>(fct: () => Promise<T> | T): Promise<PromiseSettledResult<T>>;
 }
 declare module "modern-async" {
     export { default as asyncIterableWrap } from "asyncIterableWrap";
@@ -175,7 +175,7 @@ declare module "modern-async" {
     export { default as CancelledError } from "CancelledError";
     export { default as Deferred } from "Deferred";
     export { default as asyncDelay } from "asyncDelay";
-    export { default as delayCancellable } from "delayCancellable";
+    export { default as asyncDelayCancellable } from "asyncDelayCancellable";
     export { default as Delayer } from "Delayer";
     export { default as asyncEvery } from "asyncEvery";
     export { default as asyncFilter } from "asyncFilter";
@@ -190,14 +190,14 @@ declare module "modern-async" {
     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 asyncSleep } from "asyncSleep";
+    export { default as asyncSleepCancellable } from "asyncSleepCancellable";
+    export { default as asyncSleepPrecise } from "asyncSleepPrecise";
+    export { default as asyncSleepPreciseCancellable } from "asyncSleepPreciseCancellable";
     export { default as asyncSome } from "asyncSome";
-    export { default as timeout } from "timeout";
+    export { default as asyncTimeout } from "asyncTimeout";
     export { default as TimeoutError } from "TimeoutError";
-    export { default as timeoutPrecise } from "timeoutPrecise";
-    export { default as iterableToArray } from "iterableToArray";
-    export { default as reflectStatus } from "reflectStatus";
+    export { default as asyncTimeoutPrecise } from "asyncTimeoutPrecise";
+    export { default as asyncIterableToArray } from "asyncIterableToArray";
+    export { default as reflectAsyncStatus } from "reflectAsyncStatus";
 }

src/Deferred.mjs

@@ -6,11 +6,11 @@
  * internally and can be useful to code other asynchronous helpers.
  *
  * @example
- * import { Deferred, sleep } from 'modern-async'
+ * import { Deferred, asyncSleep } from 'modern-async'
  *
  * const deferred = new Deferred()
  *
- * sleep(10).then(() => {
+ * asyncSleep(10).then(() => {
  *   deferred.resolve('test')
  * })
  *

src/Queue.mjs

@@ -15,7 +15,7 @@ import queueMicrotask from './queueMicrotask.mjs'
  * Once a task is completed, its corresponding promise is terminated accordingly.
  *
  * @example
- * import { Queue, sleep } from 'modern-async'
+ * import { Queue, asyncSleep } from 'modern-async'
  *
  * const queue = new Queue(3) // create a queue with concurrency 3
  *
@@ -25,7 +25,7 @@ import queueMicrotask from './queueMicrotask.mjs'
  * for (const i of array) {
  *   promises.push(queue.exec(async () => {
  *     console.log(`Starting task ${i}`)
- *     await sleep(Math.random() * 10) // waits a random amount of time between 0ms and 10ms
+ *     await asyncSleep(Math.random() * 10) // waits a random amount of time between 0ms and 10ms
  *     console.log(`Ending task ${i}`)
  *     return i;
  *   }))

src/Scheduler.mjs

@@ -1,5 +1,5 @@
 
-import sleepCancellable from './sleepCancellable.mjs'
+import asyncSleepCancellable from './asyncSleepCancellable.mjs'
 import Queue from './Queue.mjs'
 import assert from 'nanoassert'
 import asyncWrap from './asyncWrap.mjs'
@@ -12,22 +12,22 @@ import CancelledError from './CancelledError.mjs'
  * tasks. Notably it can limit the concurrency of asynchronous tasks running in parallel.
  *
  * @example
- * import { Scheduler, sleep } from 'modern-async'
+ * import { Scheduler, asyncSleep } from 'modern-async'
  *
  * let i = 0
  * const scheduler = new Scheduler(async () => {
  *   const taskNbr = i
  *   i += 1
  *   console.log(`Starting task ${taskNbr}`)
- *   await sleep(10) // waits 10ms
+ *   await asyncSleep(10) // waits 10ms
  *   console.log(`Ending task ${taskNbr}`)
  * }, 100) // a scheduler that triggers every 100ms
  * // the default configuration uses a maximum concurrency of 1 and doesn't allow pending
  * // tasks, which mean that if a task takes more time to complete than the delay it will be skipped
  *
  * scheduler.start() // starts the scheduler
  *
- * await sleep(1000) // waits 1s, during that time the task should trigger ~ 9 times
+ * await asyncSleep(1000) // waits 1s, during that time the task should trigger ~ 9 times
  *
  * scheduler.stop() // stops the scheduler
  * console.log('Scheduler stopped')
@@ -198,13 +198,13 @@ class Scheduler {
     this._nbrTriggering += 1
     const nextTime = this._initialTime + (this.delay * this._nbrTriggering)
     const currentTime = new Date().getTime()
-    const [promise, cancel] = sleepCancellable(nextTime - currentTime)
+    const [promise, cancel] = asyncSleepCancellable(nextTime - currentTime)
     this._cancelSleep = cancel
     promise.then(() => {
       this._triggerTask()
       this._scheduleSleep()
     }, () => {
-      // ignore cancelled sleep
+      // ignore cancelled asyncSleep
     })
   }
 

src/Scheduler.test.mjs

@@ -1,6 +1,6 @@
 
 import { expect, test } from '@jest/globals'
-import sleepPrecise from './sleepPrecise.mjs'
+import asyncSleepPrecise from './asyncSleepPrecise.mjs'
 import Scheduler, { exceptionHandler } from './Scheduler.mjs'
 import CancelledError from './CancelledError.mjs'
 import Deferred from './Deferred.mjs'
@@ -21,7 +21,7 @@ test('Scheduler base', async () => {
   scheduler.start()
   expect(scheduler.started).toBe(true)
   d.resolve()
-  await sleepPrecise(unit * 1.5 * 3)
+  await asyncSleepPrecise(unit * 1.5 * 3)
   scheduler.stop()
   expect(scheduler.started).toBe(false)
   expect(callCount).toBeGreaterThanOrEqual(3)
@@ -45,7 +45,7 @@ test('Scheduler multi start stop', async () => {
   scheduler.start()
   expect(scheduler.started).toBe(true)
   d.resolve()
-  await sleepPrecise(unit * 1.5 * 3)
+  await asyncSleepPrecise(unit * 1.5 * 3)
   scheduler.stop()
   expect(scheduler.started).toBe(false)
   scheduler.stop()
@@ -71,7 +71,7 @@ test('Scheduler startImmediate', async () => {
   scheduler.start()
   expect(scheduler.started).toBe(true)
   d.resolve()
-  await sleepPrecise(unit * 1.5 * 3)
+  await asyncSleepPrecise(unit * 1.5 * 3)
   scheduler.stop()
   expect(scheduler.started).toBe(false)
   expect(callCount).toBeGreaterThanOrEqual(4)
@@ -87,13 +87,13 @@ test('Scheduler concurrency 1', async () => {
   expect(scheduler.started).toBe(false)
   scheduler.start()
   expect(scheduler.started).toBe(true)
-  await sleepPrecise(100)
+  await asyncSleepPrecise(100)
   d.resolve()
   expect(scheduler._queue.pending).toBe(0)
   scheduler.stop()
   expect(scheduler.started).toBe(false)
   expect(callCount).toBe(1)
-  await sleepPrecise(100)
+  await asyncSleepPrecise(100)
   expect(callCount).toBe(1)
 })
 
@@ -109,14 +109,14 @@ test('Scheduler pending', async () => {
   expect(scheduler.started).toBe(false)
   scheduler.start()
   expect(scheduler.started).toBe(true)
-  await sleepPrecise(150)
+  await asyncSleepPrecise(150)
   expect(scheduler._queue.pending).toBeGreaterThan(3)
   scheduler.stop()
   expect(scheduler._queue.pending).toBe(0)
   expect(scheduler.started).toBe(false)
   expect(callCount).toBe(1)
   d.resolve()
-  await sleepPrecise(150)
+  await asyncSleepPrecise(150)
   expect(callCount).toBe(1)
 })
 
@@ -132,13 +132,13 @@ test('Scheduler concurrency 2', async () => {
   expect(scheduler.started).toBe(false)
   scheduler.start()
   expect(scheduler.started).toBe(true)
-  await sleepPrecise(150)
+  await asyncSleepPrecise(150)
   expect(scheduler._queue.pending).toBe(0)
   scheduler.stop()
   expect(scheduler.started).toBe(false)
   expect(callCount).toBe(2)
   d.resolve()
-  await sleepPrecise(150)
+  await asyncSleepPrecise(150)
   expect(callCount).toBe(2)
 })
 

src/asyncDelay.mjs

@@ -1,5 +1,5 @@
 
-import delayCancellable from './delayCancellable.mjs'
+import asyncDelayCancellable from './asyncDelayCancellable.mjs'
 
 /**
  * A function returning a promise that will be resolved in a later task of the event loop.
@@ -15,7 +15,7 @@ import delayCancellable from './delayCancellable.mjs'
  * console.log('this executes in another tick of the event loop')
  */
 async function asyncDelay () {
-  return delayCancellable()[0]
+  return asyncDelayCancellable()[0]
 }
 
 export default asyncDelay

src/delayCancellable.mjs renamed to src/asyncDelayCancellable.mjs

@@ -17,17 +17,17 @@ import clearImmediate from 'core-js-pure/features/clear-immediate.js'
  *   * The cancel function. It will return a boolean that will be true if the promise was effectively cancelled,
  *     false otherwise.
  * @example
- * import { delayCancellable, CancelledError } from 'modern-async'
+ * import { asyncDelayCancellable, CancelledError } from 'modern-async'
  *
- * const [promise, cancel] = delayCancellable()
+ * const [promise, cancel] = asyncDelayCancellable()
  * cancel()
  * try {
  *   await promise
  * } catch (e) {
  *   console.log(e instanceof CancelledError) // prints true
  * }
  */
-function delayCancellable () {
+function asyncDelayCancellable () {
   const deferred = new Deferred()
   const id = setImmediate(deferred.resolve)
   let terminated = false
@@ -45,4 +45,4 @@ function delayCancellable () {
   }]
 }
 
-export default delayCancellable
+export default asyncDelayCancellable

src/delayCancellable.test.mjs renamed to src/asyncDelayCancellable.test.mjs

@@ -1,11 +1,11 @@
 
 import { expect, test } from '@jest/globals'
-import delayCancellable from './delayCancellable.mjs'
+import asyncDelayCancellable from './asyncDelayCancellable.mjs'
 import CancelledError from './CancelledError.mjs'
 
-test('delayCancellable', async () => {
+test('asyncDelayCancellable', async () => {
   const events = []
-  const p = delayCancellable()[0].then(() => {
+  const p = asyncDelayCancellable()[0].then(() => {
     events.push('resolved')
   })
   Promise.resolve().then(() => {
@@ -16,8 +16,8 @@ test('delayCancellable', async () => {
   expect(events).toStrictEqual(['microtask', 'resolved'])
 })
 
-test('delayCancellable cancel', async () => {
-  const [p, cancel] = delayCancellable()
+test('asyncDelayCancellable cancel', async () => {
+  const [p, cancel] = asyncDelayCancellable()
   const res = cancel()
   expect(res).toBe(true)
   try {

src/asyncEvery.mjs

@@ -29,14 +29,14 @@ import asyncFindIndex from './asyncFindIndex.mjs'
  * if a least one of them doesn't pass it. That promise will be rejected if one of the truth test throws
  * an exception.
  * @example
- * import { asyncEvery, sleep } from 'modern-async'
+ * import { asyncEvery, asyncSleep } from 'modern-async'
  *
  * const array = [1, 2, 3]
  *
  * const result = await asyncEvery(array, async (v) => {
  *   // these calls will be performed in parallel with a maximum of 2
  *   // concurrent calls
- *   await sleep(10) // waits 10ms
+ *   await asyncSleep(10) // waits 10ms
  *   return v > 0
  * }, 2)
  * console.log(result) // prints true