@dxos/async 0.8.2-main.85fa0e5 → 0.8.2-main.9f6ec58

package/dist/lib/browser/index.mjs

@@ -25,6 +25,14 @@ var combine = (...cleanupFns) => {
     cleanupFns.forEach((cleanupFn) => cleanupFn());
   };
 };
+var timeout = (cb, ms = 0) => {
+  const t = setTimeout(cb, ms);
+  return () => clearTimeout(t);
+};
+var interval = (cb, ms) => {
+  const t = setInterval(cb, ms);
+  return () => clearInterval(t);
+};
 var addEventListener = (el, event, handler, options) => {
   el.addEventListener(event, handler, options);
   return () => el.removeEventListener(event, handler, options);
@@ -68,8 +76,8 @@ var debounce = (cb, wait = 100) => {
 // packages/common/async/src/errors.ts
 var toError = (err) => err === void 0 || typeof err === "string" ? new Error(err) : err;
 var TimeoutError = class extends Error {
-  constructor(timeout, label) {
-    super(timeout ? `Timeout [${timeout.toLocaleString()}ms]${label === void 0 ? "" : `: ${label}`}` : "Timeout");
+  constructor(timeout2, label) {
+    super(timeout2 ? `Timeout [${timeout2.toLocaleString()}ms]${label === void 0 ? "" : `: ${label}`}` : "Timeout");
   }
 };
 var observableError = (observable, err) => {
@@ -97,13 +105,13 @@ var sleep = (ms) => {
   });
 };
 var asyncReturn = () => sleep(0);
-var asyncTimeout = async (promise, timeout, err) => {
+var asyncTimeout = async (promise, timeout2, err) => {
   let timeoutId;
-  const throwable = err === void 0 || typeof err === "string" ? new TimeoutError(timeout, err) : err;
+  const throwable = err === void 0 || typeof err === "string" ? new TimeoutError(timeout2, err) : err;
   const timeoutPromise = new Promise((resolve, reject) => {
     timeoutId = setTimeout(() => {
       reject(throwable);
-    }, timeout);
+    }, timeout2);
     unrefTimeout(timeoutId);
   });
   const conditionTimeout = typeof promise === "function" ? createPromiseFromCallback(promise) : promise;
@@ -126,12 +134,12 @@ var sleepWithContext = (ctx, ms) => {
       reject(error);
       return;
     }
-    const timeout = setTimeout(() => {
+    const timeout2 = setTimeout(() => {
       clearDispose();
       resolve();
     }, ms);
     const clearDispose = ctx.onDispose(() => {
-      clearTimeout(timeout);
+      clearTimeout(timeout2);
       reject(error);
     });
   });
@@ -148,7 +156,7 @@ var addListener = (eventEmitter, eventName, callback) => {
     remove: () => off()
   };
 };
-var waitForEvent = (eventEmitter, eventName, test, timeout, error) => {
+var waitForEvent = (eventEmitter, eventName, test, timeout2, error) => {
   let off;
   const promise = new Promise((resolve) => {
     off = onEvent(eventEmitter, eventName, (...args) => {
@@ -157,7 +165,7 @@ var waitForEvent = (eventEmitter, eventName, test, timeout, error) => {
       }
     });
   });
-  return timeout ? asyncTimeout(promise, timeout, error ?? new Error()).finally(off) : promise.finally(off);
+  return timeout2 ? asyncTimeout(promise, timeout2, error ?? new Error()).finally(off) : promise.finally(off);
 };
 
 // packages/common/async/src/events.ts
@@ -352,14 +360,14 @@ var Event = class _Event {
   * the event is emitted after `timeout / 8` ms.
   */
   // TODO(burdon): Factor out generic function.
-  debounce(timeout = 0) {
+  debounce(timeout2 = 0) {
     let firing;
     let lastFired;
     const debouncedEvent = new _Event();
     debouncedEvent.addEffect(() => {
       const unsubscribe = this.on(() => {
         if (!firing) {
-          const fireIn = !lastFired || Date.now() - lastFired > timeout ? timeout / 8 : timeout;
+          const fireIn = !lastFired || Date.now() - lastFired > timeout2 ? timeout2 / 8 : timeout2;
           firing = setTimeout(() => {
             lastFired = Date.now();
             firing = void 0;
@@ -381,6 +389,13 @@ var Event = class _Event {
     return this;
   }
   /**
+  * Pipe the events into another event.
+  * @param event
+  */
+  pipeInto(event) {
+    return this.on((data) => event.emit(data));
+  }
+  /**
   * Overridden to not return implementation details.
   */
   toJSON() {
@@ -484,7 +499,7 @@ var weakListeners = () => {
 // packages/common/async/src/latch.ts
 import { invariant } from "@dxos/invariant";
 var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/async/src/latch.ts";
-var latch = ({ count = 1, timeout } = {}) => {
+var latch = ({ count = 1, timeout: timeout2 } = {}) => {
   invariant(count >= 0, void 0, {
     F: __dxlog_file2,
     L: 19,
@@ -512,10 +527,10 @@ var latch = ({ count = 1, timeout } = {}) => {
       doResolve(0);
     });
   } else {
-    if (timeout) {
+    if (timeout2) {
       t = setTimeout(() => {
-        doReject(new Error(`Timed out after ${timeout.toLocaleString()}ms`));
-      }, timeout);
+        doReject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`));
+      }, timeout2);
     }
   }
   let i = 0;
@@ -628,11 +643,11 @@ import Observable from "zen-observable";
 import PushStream from "zen-push";
 
 // packages/common/async/src/trigger.ts
-var trigger = (timeout) => {
+var trigger = (timeout2) => {
   let callback;
   const promise = new Promise((resolve, reject) => {
-    if (timeout) {
-      setTimeout(() => reject(new Error(`Timed out after ${timeout.toLocaleString()}ms`)), timeout);
+    if (timeout2) {
+      setTimeout(() => reject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`)), timeout2);
     }
     callback = resolve;
   });
@@ -643,12 +658,12 @@ var trigger = (timeout) => {
     resolver
   ];
 };
-var TriggerState;
-(function(TriggerState2) {
+var TriggerState = /* @__PURE__ */ function(TriggerState2) {
   TriggerState2["WAITING"] = "WAITING";
   TriggerState2["RESOLVED"] = "RESOLVED";
   TriggerState2["REJECTED"] = "REJECTED";
-})(TriggerState || (TriggerState = {}));
+  return TriggerState2;
+}({});
 var Trigger = class {
   constructor(_options = {
     autoReset: false
@@ -663,9 +678,9 @@ var Trigger = class {
   /**
   * Wait until wake is called, with optional timeout.
   */
-  async wait({ timeout } = {}) {
-    if (timeout) {
-      return asyncTimeout(this._promise, timeout, new TimeoutError(timeout));
+  async wait({ timeout: timeout2 } = {}) {
+    if (timeout2) {
+      return asyncTimeout(this._promise, timeout2, new TimeoutError(timeout2));
     } else {
       return this._promise;
     }
@@ -718,11 +733,7 @@ var Trigger = class {
 // packages/common/async/src/observable.ts
 var MulticastObservable = class _MulticastObservable extends Observable {
   constructor(subscriber, _value) {
-    super((observer) => this._subscribe(observer));
-    this._value = _value;
-    this._observers = /* @__PURE__ */ new Set();
-    this._completed = new Trigger();
-    this._handlers = {
+    super((observer) => this._subscribe(observer)), this._value = _value, this._observers = /* @__PURE__ */ new Set(), this._completed = new Trigger(), this._handlers = {
       next: (value) => {
         this._value = value;
         this._observers.forEach((observer) => observer.next?.(value));
@@ -772,9 +783,9 @@ var MulticastObservable = class _MulticastObservable extends Observable {
   *
   * @returns Promise that resolves to the value of the observable at the time of completion.
   */
-  async wait({ timeout } = {}) {
+  async wait({ timeout: timeout2 } = {}) {
     await this._completed.wait({
-      timeout
+      timeout: timeout2
     });
     return this.get();
   }
@@ -851,9 +862,7 @@ var ObservableProvider = class {
 };
 var CancellableObservableProvider = class extends ObservableProvider {
   constructor(_handleCancel) {
-    super();
-    this._handleCancel = _handleCancel;
-    this._cancelled = false;
+    super(), this._handleCancel = _handleCancel, this._cancelled = false;
   }
   get cancelled() {
     return this._cancelled;
@@ -1036,17 +1045,17 @@ var scheduleTask = (ctx, fn, afterMs) => {
     name: `task (${fn.name || "anonymous"})`,
     openStack: new StackTrace2()
   }));
-  const timeout = setTimeout(async () => {
+  const timeout2 = setTimeout(async () => {
     clearDispose();
     await runInContextAsync(ctx, fn);
     clearTracking();
   }, afterMs);
   const clearDispose = ctx.onDispose(() => {
     clearTracking();
-    clearTimeout(timeout);
+    clearTimeout(timeout2);
   });
 };
-var scheduleTaskInterval = (ctx, task, interval) => {
+var scheduleTaskInterval = (ctx, task, interval2) => {
   const clearTracking = trackResource(() => ({
     name: `repeating task (${task.name || "anonymous"})`,
     openStack: new StackTrace2()
@@ -1057,9 +1066,9 @@ var scheduleTaskInterval = (ctx, task, interval) => {
     if (ctx.disposed) {
       return;
     }
-    timeoutId = setTimeout(run, interval);
+    timeoutId = setTimeout(run, interval2);
   };
-  timeoutId = setTimeout(run, interval);
+  timeoutId = setTimeout(run, interval2);
   ctx.onDispose(() => {
     clearTracking();
     clearTimeout(timeoutId);
@@ -1071,16 +1080,16 @@ var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
     openStack: new StackTrace2()
   }));
   let timeoutId;
-  let interval = initialInterval;
+  let interval2 = initialInterval;
   const repeat = async () => {
     await runInContextAsync(ctx, task);
     if (ctx.disposed) {
       return;
     }
-    interval *= 2;
-    timeoutId = setTimeout(repeat, interval);
+    interval2 *= 2;
+    timeoutId = setTimeout(repeat, interval2);
   };
-  timeoutId = setTimeout(repeat, interval);
+  timeoutId = setTimeout(repeat, interval2);
   ctx.onDispose(() => {
     clearTracking();
     clearTimeout(timeoutId);
@@ -1328,15 +1337,15 @@ var TestStream = class extends Duplex {
     this._received = Buffer.alloc(0);
     this._onWrite = new Event();
   }
-  static async assertConnectivity(stream1, stream2, { timeout = 200 } = {}) {
+  static async assertConnectivity(stream1, stream2, { timeout: timeout2 = 200 } = {}) {
     stream1.push("ping");
     stream2.push("pong");
     await Promise.all([
       stream2.assertReceivedAsync("ping", {
-        timeout
+        timeout: timeout2
       }),
       stream1.assertReceivedAsync("pong", {
-        timeout
+        timeout: timeout2
       })
     ]);
   }
@@ -1350,15 +1359,15 @@ var TestStream = class extends Duplex {
   }
   _read(size) {
   }
-  assertReceivedAsync(data, { timeout = 200 } = {}) {
+  assertReceivedAsync(data, { timeout: timeout2 = 200 } = {}) {
     const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout);
+    return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout2);
   }
 };
 
 // packages/common/async/src/testing.ts
-var waitForCondition = ({ condition, timeout = 0, interval = 10, error }) => {
-  const stopTime = timeout ? Date.now() + timeout : 0;
+var waitForCondition = ({ condition, timeout: timeout2 = 0, interval: interval2 = 10, error, breakOnError = false }) => {
+  const stopTime = timeout2 ? Date.now() + timeout2 : 0;
   const trigger2 = new Trigger();
   const waiter = async () => {
     while (!stopTime || Date.now() < stopTime) {
@@ -1369,12 +1378,17 @@ var waitForCondition = ({ condition, timeout = 0, interval = 10, error }) => {
           break;
         }
       } catch (err) {
+        if (breakOnError === true) {
+          trigger2.throw(err);
+        }
       }
-      await sleep(interval);
+      await sleep(interval2);
     }
   };
   setTimeout(waiter, 0);
-  return timeout ? asyncTimeout(trigger2.wait(), timeout, error ?? new Error("Timeout")) : trigger2.wait();
+  return trigger2.wait({
+    timeout: timeout2
+  });
 };
 
 // packages/common/async/src/timer.ts
@@ -1405,11 +1419,11 @@ var Timer = class {
       if (this._count >= (options.count ?? 0)) {
         stop();
       } else {
-        const interval = (options.interval ?? 0) + Math.random() * (options.jitter ?? 0);
+        const interval2 = (options.interval ?? 0) + Math.random() * (options.jitter ?? 0);
         this._timer = setTimeout(async () => {
           await this._callback(this._count++);
           run();
-        }, interval);
+        }, interval2);
       }
     };
     this._state.emit(true);
@@ -1426,11 +1440,11 @@ var Timer = class {
 };
 
 // packages/common/async/src/until.ts
-var until = (cb, timeout) => {
+var until = (cb, timeout2) => {
   return new Promise((resolve, reject) => {
-    const t = timeout && setTimeout(() => {
+    const t = timeout2 && setTimeout(() => {
       reject(new Error(`Timeout after ${t}ms`));
-    }, timeout);
+    }, timeout2);
     setTimeout(async () => {
       try {
         await cb((value) => {
@@ -1559,6 +1573,7 @@ export {
   createPromiseFromCallback,
   debounce,
   dumpLeaks,
+  interval,
   latch,
   makePushIterable,
   observableError,
@@ -1574,6 +1589,7 @@ export {
   sleepWithContext,
   streamToArray,
   synchronized,
+  timeout,
   toError,
   trackLeaks,
   trackResource,