@dxos/async 0.8.1 → 0.8.2-main.10c050d

package/src/observable.ts

@@ -38,7 +38,10 @@ export class MulticastObservable<T> extends Observable<T> {
     this._observable.subscribe(this._handlers);
   }
 
-  static override from<T>(value: Observable<T> | ObservableLike<T> | ArrayLike<T> | Event<T>, initialValue?: T) {
+  static override from<T>(
+    value: Observable<T> | ObservableLike<T> | ArrayLike<T> | Event<T>,
+    initialValue?: T,
+  ): MulticastObservable<T> {
     if ('emit' in value) {
       return new MulticastObservable((observer) => {
         // TODO(wittjosiah): Do error/complete matter for events?
@@ -52,14 +55,14 @@ export class MulticastObservable<T> extends Observable<T> {
     return new MulticastObservable(observable, initialValue);
   }
 
-  static override of<T>(...items: T[]) {
+  static override of<T>(...items: T[]): MulticastObservable<T> {
     return new MulticastObservable(Observable.of(...items.slice(1)), items[0]);
   }
 
   /**
    * @returns Stable reference to an observable that always returns `undefined`.
    */
-  static empty() {
+  static empty(): MulticastObservable<null> {
     return EMPTY_OBSERVABLE;
   }
 
@@ -137,7 +140,7 @@ export class MulticastObservable<T> extends Observable<T> {
     return new MulticastObservable(this._observable.concat(...observables), value);
   }
 
-  private _subscribe(observer: Observer<T>) {
+  private _subscribe(observer: Observer<T>): () => void {
     if (!this._observers.has(observer)) {
       this._observers.add(observer);
     }

package/src/persistent-lifecycle.test.ts

@@ -25,7 +25,7 @@ describe('ConnectionState', () => {
     });
 
     const triggerTimestamp = Date.now();
-    persistentLifecycle.scheduleRestart();
+    void persistentLifecycle.scheduleRestart();
     const timeToTrigger = (await triggerCall.wait({ timeout: 1000 })) - triggerTimestamp;
     expect(timeToTrigger).to.be.lessThan(50);
   });
@@ -69,7 +69,7 @@ describe('ConnectionState', () => {
 
     await persistentLifecycle.open();
 
-    persistentLifecycle.scheduleRestart();
+    void persistentLifecycle.scheduleRestart();
     await sleep(10);
     await persistentLifecycle.close();
     expect(restarted).to.be.true;

package/src/persistent-lifecycle.ts

@@ -64,7 +64,7 @@ export class PersistentLifecycle<T> extends Resource {
   }
 
   @synchronized
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     this._restartTask = new DeferredTask(this._ctx, async () => {
       try {
         await this._restart();
@@ -80,13 +80,13 @@ export class PersistentLifecycle<T> extends Resource {
     });
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     await this._restartTask?.join();
     await this._stopCurrentState();
     this._restartTask = undefined;
   }
 
-  private async _restart() {
+  private async _restart(): Promise<void> {
     log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
     await this._stopCurrentState();
     if (this._lifecycleState !== LifecycleState.OPEN) {
@@ -104,7 +104,7 @@ export class PersistentLifecycle<T> extends Resource {
     await this._onRestart?.();
   }
 
-  private async _stopCurrentState() {
+  private async _stopCurrentState(): Promise<void> {
     if (this._currentState) {
       try {
         await this._stop(this._currentState);
@@ -119,7 +119,7 @@ export class PersistentLifecycle<T> extends Resource {
    * Scheduling restart should be done from outside.
    */
   @synchronized
-  scheduleRestart() {
+  async scheduleRestart(): Promise<void> {
     if (this._lifecycleState !== LifecycleState.OPEN) {
       return;
     }

package/src/task-scheduling.ts

@@ -33,7 +33,7 @@ export class DeferredTask {
   /**
    * Schedule the task to run asynchronously.
    */
-  schedule() {
+  schedule(): void {
     if (this._scheduled) {
       return; // Already scheduled.
     }
@@ -59,7 +59,7 @@ export class DeferredTask {
   /**
    * Schedule the task to run and wait for it to finish.
    */
-  async runBlocking() {
+  async runBlocking(): Promise<void> {
     if (this._ctx.disposed) {
       throw new ContextDisposedError();
     }
@@ -72,7 +72,7 @@ export class DeferredTask {
    * Waits for the current task to finish if it is running.
    * Does not schedule a new task.
    */
-  async join() {
+  async join(): Promise<void> {
     await this._currentTask;
   }
 }

package/src/test-stream.ts

@@ -16,7 +16,7 @@ export class TestStream extends Duplex {
     stream1: TestStream,
     stream2: TestStream,
     { timeout = 200 }: { timeout?: number } = {},
-  ) {
+  ): Promise<void> {
     stream1.push('ping');
     stream2.push('pong');
 
@@ -39,7 +39,7 @@ export class TestStream extends Duplex {
     // noop
   }
 
-  assertReceivedAsync(data: Buffer | string, { timeout = 200 }: { timeout?: number } = {}) {
+  assertReceivedAsync(data: Buffer | string, { timeout = 200 }: { timeout?: number } = {}): Promise<void> {
     const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
     return asyncTimeout(
       this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)),

package/src/testing.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { expectToThrow } from '@dxos/debug';
+import { expectToThrow, raise } from '@dxos/debug';
 
 import { waitForCondition } from './testing';
 
@@ -20,4 +20,10 @@ describe('waitForCondition', () => {
     const stop = Date.now() + 200;
     await expectToThrow(() => waitForCondition({ condition: () => Date.now() > stop, timeout: 100 }));
   });
+
+  test('breakOnError', async () => {
+    await expect(() =>
+      waitForCondition({ condition: () => raise(new Error('test')), timeout: 100, breakOnError: true }),
+    ).rejects.toThrow('test');
+  });
 });

package/src/testing.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { asyncTimeout, sleep } from './timeout';
+import { sleep } from './timeout';
 import { Trigger } from './trigger';
 
 /**
@@ -19,11 +19,13 @@ export const waitForCondition = <FunctionType extends (...args: any) => any>({
   timeout = 0,
   interval = 10,
   error,
+  breakOnError = false,
 }: {
   condition: FunctionType;
   timeout?: number;
   interval?: number;
   error?: Error;
+  breakOnError?: boolean;
 }) => {
   const stopTime = timeout ? Date.now() + timeout : 0;
   const trigger = new Trigger<ReturnType<FunctionType>>();
@@ -37,8 +39,10 @@ export const waitForCondition = <FunctionType extends (...args: any) => any>({
           trigger.wake(value);
           break;
         }
-      } catch (err) {
-        // Pass...
+      } catch (err: any) {
+        if (breakOnError === true) {
+          trigger.throw(err);
+        }
       }
 
       // eslint-disable-next-line no-await-in-loop
@@ -48,5 +52,5 @@ export const waitForCondition = <FunctionType extends (...args: any) => any>({
 
   setTimeout(waiter, 0);
 
-  return timeout ? asyncTimeout(trigger.wait(), timeout, error ?? new Error('Timeout')) : trigger.wait();
+  return trigger.wait({ timeout });
 };

package/src/timeout.ts

@@ -37,6 +37,7 @@ export const asyncReturn = () => sleep(0);
  * Wait for promise or throw error.
  */
 export const asyncTimeout = async <T>(
+  // TODO(dmaretskyi): This callback API is unintuitive and leads to bugs.
   promise: Promise<T> | (() => Promise<T>),
   timeout: number,
   err?: Error | string,

package/src/timer.ts

@@ -27,7 +27,7 @@ export class Timer {
     return !!this._timer;
   }
 
-  start(options: TimerOptions, cb?: () => void) {
+  start(options: TimerOptions, cb?: () => void): this {
     if (isNaN(options.count) || isNaN(options.interval)) {
       throw new Error(`Invalid options: ${JSON.stringify(options)}`);
     }
@@ -61,7 +61,7 @@ export class Timer {
     return this;
   }
 
-  stop() {
+  stop(): this {
     clearInterval(this._timer);
     this._timer = undefined;
     this._state.emit(false);

package/src/trigger.ts

@@ -77,7 +77,7 @@ export class Trigger<T = void> {
    * Wake blocked callers (if any).
    * NOOP if the trigger is already resolved.
    */
-  wake(value: T) {
+  wake(value: T): this {
     if (this._state !== TriggerState.WAITING) {
       return this;
     }
@@ -93,7 +93,7 @@ export class Trigger<T = void> {
   /**
    * Reset promise (new waiters will wait).
    */
-  reset() {
+  reset(): this {
     this._state = TriggerState.WAITING;
     this._promise = new Promise<T>((resolve, reject) => {
       this._resolve = resolve;
@@ -108,7 +108,7 @@ export class Trigger<T = void> {
    * Throw error to blocked callers (if any).
    * NOOP if the trigger is already resolved.
    */
-  throw(error: Error) {
+  throw(error: Error): this {
     if (this._state !== TriggerState.WAITING) {
       return this;
     }

package/src/update-scheduler.ts

@@ -38,7 +38,7 @@ export class UpdateScheduler {
     });
   }
 
-  trigger() {
+  trigger(): void {
     if (this._scheduled) {
       return;
     }
@@ -87,7 +87,7 @@ export class UpdateScheduler {
     this._scheduled = true;
   }
 
-  forceTrigger() {
+  forceTrigger(): void {
     scheduleMicroTask(this._ctx, async () => {
       this._callback().catch((err) => this._ctx.raise(err));
     });
@@ -97,14 +97,14 @@ export class UpdateScheduler {
    * Waits for the current task to finish if it is running.
    * Does not schedule a new task.
    */
-  async join() {
+  async join(): Promise<void> {
     await this._promise;
   }
 
   /**
    * Force schedule the task to run and wait for it to finish.
    */
-  async runBlocking() {
+  async runBlocking(): Promise<void> {
     // The previous task might still be running, so we need to wait for it to finish.
     await this._promise; // Can't be rejected.
     this._promise = this._callback();