@atlaspack/utils 2.12.1-dev.3478 → 2.12.1-dev.3520

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/utils",
-  "version": "2.12.1-dev.3478+5fd2da535",
+  "version": "2.12.1-dev.3520+8a5346e28",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -29,11 +29,11 @@
     }
   },
   "dependencies": {
-    "@atlaspack/codeframe": "2.12.1-dev.3478+5fd2da535",
-    "@atlaspack/diagnostic": "2.12.1-dev.3478+5fd2da535",
-    "@atlaspack/logger": "2.12.1-dev.3478+5fd2da535",
-    "@atlaspack/markdown-ansi": "2.12.1-dev.3478+5fd2da535",
-    "@atlaspack/rust": "2.12.1-dev.3478+5fd2da535",
+    "@atlaspack/codeframe": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/diagnostic": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/logger": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/markdown-ansi": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/rust": "2.12.1-dev.3520+8a5346e28",
     "@parcel/source-map": "^2.1.1",
     "chalk": "^4.1.0",
     "nullthrows": "^1.1.1"
@@ -63,5 +63,5 @@
     "./src/openInBrowser.js": false,
     "@atlaspack/markdown-ansi": false
   },
-  "gitHead": "5fd2da535ecbe096d57e03aec15e80bb1d7601f7"
+  "gitHead": "8a5346e28c1bb3b9cd40f1c4e77c66dd6666f1e4"
 }

package/src/DefaultMap.js

@@ -22,9 +22,11 @@ export class DefaultMap<K, V> extends Map<K, V> {
   }
 }
 
+interface Key {}
+
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: interface {}, V> extends WeakMap<K, V> {
+export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
   _getDefault: (K) => V;
 
   constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {

package/src/PromiseQueue.js

@@ -27,8 +27,8 @@ export default class PromiseQueue<T> {
     return this._queue.length;
   }
 
-  add(fn: () => Promise<T>): Promise<T> {
-    return new Promise((resolve, reject) => {
+  add(fn: () => Promise<T>): void {
+    new Promise((resolve, reject) => {
       let i = this._count++;
       let wrapped = () =>
         fn().then(
@@ -51,7 +51,7 @@ export default class PromiseQueue<T> {
       if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
         this._next();
       }
-    });
+    }).catch(() => {});
   }
 
   subscribeToAdd(fn: () => void): () => void {

package/src/dependency-location.js

@@ -1,10 +1,10 @@
 // @flow
 
 export default function createDependencyLocation(
-  start: interface {
+  start: {|
     line: number,
     column: number,
-  },
+  |},
   specifier: string,
   lineOffset: number = 0,
   columnOffset: number = 0,

package/test/PromiseQueue.test.js

@@ -23,37 +23,37 @@ describe('PromiseQueue', () => {
     let error = new Error('some failure');
     try {
       let queue = new PromiseQueue();
-      queue
-        .add(() => Promise.reject(error))
-        .catch(
-          /* catch this to prevent an unhandled promise rejection*/ () => {},
-        );
+      queue.add(() => Promise.reject(error));
       await queue.run();
     } catch (e) {
       assert.equal(e, error);
     }
   });
 
-  it('.run() should instantly resolve when the queue is empty', async () => {
-    let queue = new PromiseQueue();
-    await queue.run();
-    // no need to assert, test will hang or throw an error if condition fails
+  it('run() should reject if any of the async functions in the queue throwo', async () => {
+    let error = new Error('some failure');
+    try {
+      let queue = new PromiseQueue();
+      queue.add(() => {
+        throw error;
+      });
+      await queue.run();
+    } catch (e) {
+      assert.equal(e, error);
+    }
   });
 
-  it(".add() should resolve with the same result when the passed in function's promise resolves", async () => {
+  it('.run() should instantly resolve when the queue is empty', async () => {
     let queue = new PromiseQueue();
-    let promise = queue.add(() => Promise.resolve(42));
     await queue.run();
-    let result = await promise;
-    assert.equal(result, 42);
+    // no need to assert, test will hang or throw an error if condition fails
   });
 
-  it(".add() should reject with the same error when the passed in function's promise rejects", async () => {
+  it('.add() result should bubble into the run results', async () => {
     let queue = new PromiseQueue();
-    let error = new Error('Oh no!');
-    let promise = queue.add(() => Promise.reject(error));
-    await queue.run().catch(() => null);
-    await promise.then(null, (e) => assert.equal(e, error));
+    queue.add(() => Promise.resolve(42));
+    const result = await queue.run();
+    assert.deepEqual(result, [42]);
   });
 
   it('constructor() should allow for configuration of max concurrent running functions', async () => {
@@ -87,6 +87,31 @@ describe('PromiseQueue', () => {
     assert(subscribedFn.called);
   });
 
+  it('runs functions concurrently', () => {
+    const queue = new PromiseQueue();
+
+    const fn1 = sinon
+      .stub()
+      .returns(new Promise((resolve) => setTimeout(resolve, 5000)));
+
+    queue.add(fn1); // queue does not work if nothing is running, this is broken behaviour
+    queue.run();
+
+    const fn2 = sinon
+      .stub()
+      .returns(new Promise((resolve) => setTimeout(resolve, 5000)));
+    const fn3 = sinon
+      .stub()
+      .returns(new Promise((resolve) => setTimeout(resolve, 5000)));
+
+    queue.add(fn2);
+    queue.add(fn3);
+
+    assert(fn1.calledOnce);
+    assert(fn2.calledOnce);
+    assert(fn3.calledOnce);
+  });
+
   it('.subscribeToAdd() should allow unsubscribing', async () => {
     const queue = new PromiseQueue();