@dxos/async 0.5.4 → 0.5.5-main.23d7ea6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/async",
-  "version": "0.5.4",
+  "version": "0.5.5-main.23d7ea6",
   "description": "Async utilities.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -18,12 +18,12 @@
   "dependencies": {
     "zen-observable": "^0.10.0",
     "zen-push": "^0.3.1",
-    "@dxos/context": "0.5.4",
-    "@dxos/debug": "0.5.4",
-    "@dxos/invariant": "0.5.4",
-    "@dxos/log": "0.5.4",
-    "@dxos/node-std": "0.5.4",
-    "@dxos/util": "0.5.4"
+    "@dxos/context": "0.5.5-main.23d7ea6",
+    "@dxos/debug": "0.5.5-main.23d7ea6",
+    "@dxos/log": "0.5.5-main.23d7ea6",
+    "@dxos/invariant": "0.5.5-main.23d7ea6",
+    "@dxos/util": "0.5.5-main.23d7ea6",
+    "@dxos/node-std": "0.5.5-main.23d7ea6"
   },
   "devDependencies": {
     "@types/zen-observable": "^0.8.3"

package/src/trigger.test.ts

@@ -2,12 +2,15 @@
 // Copyright 2020 DXOS.org
 //
 
-import { expect } from 'chai';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 
 import { describe, test } from '@dxos/test';
 
 import { sleep } from './timeout';
-import { Trigger, trigger } from './trigger';
+import { Trigger, TriggerState, trigger } from './trigger';
+
+chai.use(chaiAsPromised);
 
 describe('trigger', () => {
   test('trigger', async () => {
@@ -27,4 +30,32 @@ describe('trigger', () => {
     trigger.reset();
     await sleep(10);
   });
+
+  test('states are set correctly', async () => {
+    const trigger = new Trigger<string>();
+
+    expect(trigger.state).to.equal(TriggerState.WAITING);
+
+    {
+      const promise = trigger.wait();
+      trigger.wake('test');
+      expect(await promise).to.equal('test');
+      expect(trigger.state).to.equal(TriggerState.RESOLVED);
+    }
+
+    {
+      trigger.reset();
+      expect(trigger.state).to.equal(TriggerState.WAITING);
+    }
+
+    {
+      const error = new Error('Test error');
+      const promise = trigger.wait();
+      trigger.throw(error);
+      await expect(promise).to.be.rejectedWith(error);
+      expect(trigger.state).to.equal(TriggerState.REJECTED);
+      trigger.reset();
+      expect(trigger.state).to.equal(TriggerState.WAITING);
+    }
+  });
 });

package/src/trigger.ts

@@ -31,12 +31,19 @@ export type TriggerOptions = {
   autoReset: boolean;
 };
 
+export enum TriggerState {
+  WAITING = 'WAITING',
+  RESOLVED = 'RESOLVED',
+  REJECTED = 'REJECTED',
+}
+
 /**
  * Enables blocked listeners to be awakened with optional timeouts.
  *
  * Has two states:
  * - WAITING: promise is in pending state and will be resolved once `wake()` is called.
- * - READY: promise is already resolved, and all calls to `wait()` resolve immediately.
+ * - RESOLVED: promise is already resolved, and all calls to `wait()` resolve immediately.
+ * - REJECTED: promise is rejected, and all calls to `wait()` return rejected promise.
  *
  * Trigger starts in WAITING state initially.
  * Use `reset()` to switch resolved trigger back to WAITING state.
@@ -45,11 +52,16 @@ export class Trigger<T = void> {
   private _promise!: Promise<T>;
   private _resolve!: (value: T | PromiseLike<T>) => void;
   private _reject!: (error: Error) => void;
+  private _state: TriggerState = TriggerState.WAITING;
 
   constructor(private _options: TriggerOptions = { autoReset: false }) {
     this.reset();
   }
 
+  get state() {
+    return this._state;
+  }
+
   /**
    * Wait until wake is called, with optional timeout.
    */
@@ -66,6 +78,7 @@ export class Trigger<T = void> {
    * NOOP if the trigger is already resolved.
    */
   wake(value: T) {
+    this._state = TriggerState.RESOLVED;
     this._resolve(value);
     if (this._options.autoReset) {
       return this.reset();
@@ -78,6 +91,7 @@ export class Trigger<T = void> {
    * Reset promise (new waiters will wait).
    */
   reset() {
+    this._state = TriggerState.WAITING;
     this._promise = new Promise<T>((resolve, reject) => {
       this._resolve = resolve;
       this._reject = reject;
@@ -92,6 +106,7 @@ export class Trigger<T = void> {
    * NOOP if the trigger is already resolved.
    */
   throw(error: Error) {
+    this._state = TriggerState.REJECTED;
     this._reject(error);
     if (this._options.autoReset) {
       return this.reset();