@parcel/events 2.0.0-nightly.97 → 2.0.0-nightly.970

package/lib/Disposable.js

@@ -5,17 +5,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
 
-var _errors = require("./errors");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  _assert = function () {
+    return data;
+  };
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  return data;
+}
 
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+var _errors = require("./errors");
 
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /*
  * A general-purpose disposable class. It can normalize disposable-like values
@@ -23,16 +25,13 @@ function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = p
  * disposable-like values to be disposed of at once.
  */
 class Disposable {
-  // ?Set<DisposableLike>
-  constructor(...disposables) {
-    _defineProperty(this, "disposed", false);
+  disposed = false;
+  #disposables
+  /*: ?Set<DisposableLike> */
+  ;
 
-    _disposables.set(this, {
-      writable: true,
-      value: void 0
-    });
-
-    _classPrivateFieldSet(this, _disposables, new Set(disposables));
+  constructor(...disposables) {
+    this.#disposables = new Set(disposables);
   }
 
   add(...disposables) {
@@ -40,35 +39,24 @@ class Disposable {
       throw new _errors.AlreadyDisposedError('Cannot add new disposables after disposable has been disposed');
     }
 
-    (0, _assert.default)(_classPrivateFieldGet(this, _disposables) != null);
+    (0, _assert().default)(this.#disposables != null);
 
     for (let disposable of disposables) {
-      _classPrivateFieldGet(this, _disposables).add(disposable);
+      this.#disposables.add(disposable);
     }
   }
 
-  dispose() {
+  async dispose() {
     if (this.disposed) {
       return;
     }
 
-    (0, _assert.default)(_classPrivateFieldGet(this, _disposables) != null);
-
-    for (let disposable of _classPrivateFieldGet(this, _disposables)) {
-      if (typeof disposable === 'function') {
-        disposable();
-      } else {
-        disposable.dispose();
-      }
-    }
-
-    _classPrivateFieldSet(this, _disposables, null);
-
     this.disposed = true;
+    (0, _assert().default)(this.#disposables != null);
+    await Promise.all([...this.#disposables].map(disposable => typeof disposable === 'function' ? disposable() : disposable.dispose()));
+    this.#disposables = null;
   }
 
 }
 
-exports.default = Disposable;
-
-var _disposables = new WeakMap();
+exports.default = Disposable;

package/lib/ValueEmitter.js

@@ -7,18 +7,16 @@ exports.default = void 0;
 
 var _errors = require("./errors");
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 // Like an EventEmitter, but for only a single "event". This provides type-safety
 // for the values emitted. Rather than passing predetermined strings (which can
 // be misspelled), create an instance of ValueEmitter for every logical "event"
 // to be dispatched, and type it according to the type of value emitted.
 class ValueEmitter {
-  constructor() {
-    _defineProperty(this, "_listeners", []);
-
-    _defineProperty(this, "_disposed", false);
-  }
+  // An array of listeners. One might think a Set would be better for O(1) removal,
+  // but splicing a JS array gets pretty close, and copying the array (as is done
+  // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
+  _listeners = [];
+  _disposed = false;
 
   addListener(listener) {
     if (this._disposed) {
@@ -44,10 +42,11 @@ class ValueEmitter {
           return;
         }
 
-        let listenerIndex = emitter._listeners.indexOf(listener);
+        let listeners = emitter._listeners;
+        let listenerIndex = listeners.indexOf(listener);
 
         if (listenerIndex > -1) {
-          emitter._listeners.splice(listenerIndex, 1);
+          listeners.splice(listenerIndex, 1);
         }
 
         emitter = null;

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@parcel/events",
-  "version": "2.0.0-nightly.97+a63f3fc9",
+  "version": "2.0.0-nightly.970+5a80fbe4",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
@@ -12,7 +16,7 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 12.0.0"
   },
-  "gitHead": "a63f3fc9726483219412920faeb255e035f90747"
+  "gitHead": "5a80fbe4af8797d0aab248a66f5254f42f00e83e"
 }

package/src/Disposable.js

@@ -14,7 +14,7 @@ type DisposableLike = IDisposable | (() => mixed);
  */
 export default class Disposable implements IDisposable {
   disposed: boolean = false;
-  #disposables; // ?Set<DisposableLike>
+  #disposables /*: ?Set<DisposableLike> */;
 
   constructor(...disposables: Array<DisposableLike>) {
     this.#disposables = new Set(disposables);
@@ -33,21 +33,20 @@ export default class Disposable implements IDisposable {
     }
   }
 
-  dispose(): void {
+  async dispose(): Promise<void> {
     if (this.disposed) {
       return;
     }
 
+    this.disposed = true;
+
     invariant(this.#disposables != null);
-    for (let disposable of this.#disposables) {
-      if (typeof disposable === 'function') {
-        disposable();
-      } else {
-        disposable.dispose();
-      }
-    }
+    await Promise.all(
+      [...this.#disposables].map(disposable =>
+        typeof disposable === 'function' ? disposable() : disposable.dispose(),
+      ),
+    );
 
     this.#disposables = null;
-    this.disposed = true;
   }
 }

package/src/ValueEmitter.js

@@ -41,9 +41,10 @@ export default class ValueEmitter<TValue> implements IDisposable {
           return;
         }
 
-        let listenerIndex = emitter._listeners.indexOf(listener);
+        let listeners = emitter._listeners;
+        let listenerIndex = listeners.indexOf(listener);
         if (listenerIndex > -1) {
-          emitter._listeners.splice(listenerIndex, 1);
+          listeners.splice(listenerIndex, 1);
         }
 
         emitter = null;

package/src/types.js

@@ -1,5 +1,8 @@
 // @flow strict-local
 
 export interface IDisposable {
-  dispose(): void;
+  /** This can return a Promise, as dispose() of all inner disposables are
+   * awaited in Disposable#dispose()
+   */
+  dispose(): mixed;
 }