@dxos/async 0.8.4-main.f5c0578 → 0.8.4-main.fbb7a13

package/dist/lib/browser/index.mjs

@@ -64,29 +64,55 @@ var SubscriptionSet = class {
 };
 
 // src/debounce.ts
-var debounce = (cb, delay = 100) => {
+var delay = (cb, delay2 = 100) => {
+  let pending = false;
+  return (...args) => {
+    if (pending) {
+      return;
+    }
+    pending = true;
+    setTimeout(() => {
+      try {
+        cb(...args);
+      } finally {
+        pending = false;
+      }
+    }, delay2);
+  };
+};
+var debounce = (cb, delay2 = 100) => {
   let t;
   return (...args) => {
     clearTimeout(t);
-    t = setTimeout(() => cb(...args), delay);
+    t = setTimeout(() => cb(...args), delay2);
   };
 };
-var throttle = (cb, delay = 100) => {
+var throttle = (cb, delay2 = 100) => {
   let lastCall = 0;
   return (...args) => {
     const now = Date.now();
-    if (now - lastCall >= delay) {
+    if (now - lastCall >= delay2) {
       cb(...args);
       lastCall = now;
     }
   };
 };
-var debounceAndThrottle = (cb, delay = 100) => {
-  const debounced = debounce(cb, delay);
-  const throttled = throttle(cb, delay);
+var debounceAndThrottle = (cb, delay2 = 100) => {
+  let timeout2;
+  let lastCall = 0;
   return (...args) => {
-    debounced(...args);
-    throttled(...args);
+    const now = Date.now();
+    const delta = now - lastCall;
+    clearTimeout(timeout2);
+    if (delta >= delay2) {
+      cb(...args);
+      lastCall = now;
+    } else {
+      timeout2 = setTimeout(() => {
+        cb(...args);
+        lastCall = Date.now();
+      }, delay2 - delta);
+    }
   };
 };
 
@@ -451,12 +477,11 @@ var EventListener = class {
   once;
   weak;
   callback;
-  _clearDispose;
+  _clearDispose = void 0;
   constructor(event, listener, ctx, once, weak) {
     this.ctx = ctx;
     this.once = once;
     this.weak = weak;
-    this._clearDispose = void 0;
     this._clearDispose = ctx.onDispose(() => {
       event._removeListener(this);
     });
@@ -629,23 +654,22 @@ var trigger = (timeout2) => {
     resolver
   ];
 };
-var TriggerState = /* @__PURE__ */ function(TriggerState2) {
+var TriggerState = /* @__PURE__ */ (function(TriggerState2) {
   TriggerState2["WAITING"] = "WAITING";
   TriggerState2["RESOLVED"] = "RESOLVED";
   TriggerState2["REJECTED"] = "REJECTED";
   return TriggerState2;
-}({});
+})({});
 var Trigger = class {
   _options;
   _promise;
   _resolve;
   _reject;
-  _state;
+  _state = "WAITING";
   constructor(_options = {
     autoReset: false
   }) {
     this._options = _options;
-    this._state = "WAITING";
     this.reset();
   }
   get state() {
@@ -755,23 +779,11 @@ var latch = ({ count = 1, timeout: timeout2 } = {}) => {
 // src/observable.ts
 var MulticastObservable = class _MulticastObservable extends Observable {
   _value;
-  _observers;
+  _observers = /* @__PURE__ */ new Set();
   _observable;
-  _completed;
+  _completed = new Trigger();
   constructor(subscriber, _value) {
-    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));
-      },
-      error: (err) => {
-        this._observers.forEach((observer) => observer.error?.(err));
-      },
-      complete: () => {
-        this._completed.wake();
-        this._observers.forEach((observer) => observer.complete?.());
-      }
-    };
+    super((observer) => this._subscribe(observer)), this._value = _value;
     this._observable = typeof subscriber === "function" ? new Observable(subscriber) : subscriber;
     this._observable.subscribe(this._handlers);
   }
@@ -855,7 +867,19 @@ var MulticastObservable = class _MulticastObservable extends Observable {
       this._observers.delete(observer);
     };
   }
-  _handlers;
+  _handlers = {
+    next: (value) => {
+      this._value = value;
+      this._observers.forEach((observer) => observer.next?.(value));
+    },
+    error: (err) => {
+      this._observers.forEach((observer) => observer.error?.(err));
+    },
+    complete: () => {
+      this._completed.wake();
+      this._observers.forEach((observer) => observer.complete?.());
+    }
+  };
 };
 var EMPTY_OBSERVABLE = MulticastObservable.of(null);
 
@@ -888,9 +912,9 @@ var ObservableProvider = class {
 };
 var CancellableObservableProvider = class extends ObservableProvider {
   _handleCancel;
-  _cancelled;
+  _cancelled = false;
   constructor(_handleCancel) {
-    super(), this._handleCancel = _handleCancel, this._cancelled = false;
+    super(), this._handleCancel = _handleCancel;
   }
   get cancelled() {
     return this._cancelled;
@@ -1002,15 +1026,12 @@ if (enabled) {
 var DeferredTask = class {
   _ctx;
   _callback;
-  _scheduled;
-  _currentTask;
-  _nextTask;
+  _scheduled = false;
+  _currentTask = null;
+  _nextTask = new Trigger();
   constructor(_ctx, _callback) {
     this._ctx = _ctx;
     this._callback = _callback;
-    this._scheduled = false;
-    this._currentTask = null;
-    this._nextTask = new Trigger();
   }
   get scheduled() {
     return this._scheduled;
@@ -1051,6 +1072,78 @@ var DeferredTask = class {
     await this._currentTask;
   }
 };
+var AsyncTask = class {
+  #callback;
+  #ctx = void 0;
+  #scheduled = false;
+  #currentTask = null;
+  #nextTask = new Trigger();
+  constructor(callback) {
+    this.#callback = callback;
+  }
+  get scheduled() {
+    return this.#scheduled;
+  }
+  /**
+  * Context of the resource that owns the task.
+  * When the context is disposed, the task is cancelled and cannot be scheduled again.
+  */
+  // TODO(dmaretskyi): We don't really need to pass ctx in here, since close will also signal dispose.
+  open(ctx) {
+    this.#ctx = ctx;
+  }
+  /**
+  * Closes the task and waits for it to finish if it is running.
+  */
+  async close() {
+    this.#ctx = void 0;
+    await this.join();
+  }
+  [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  /**
+  * Schedule the task to run asynchronously.
+  */
+  schedule() {
+    if (!this.#ctx || this.#ctx.disposed) {
+      throw new Error("AsyncTask not open");
+    }
+    if (this.#scheduled) {
+      return;
+    }
+    scheduleTask(this.#ctx, async () => {
+      await this.#currentTask;
+      if (!this.#ctx || this.#ctx.disposed) {
+        return;
+      }
+      this.#scheduled = false;
+      const completionTrigger = this.#nextTask;
+      this.#nextTask = new Trigger();
+      this.#currentTask = runInContextAsync(this.#ctx, () => this.#callback()).then(() => {
+        completionTrigger.wake();
+      });
+    });
+    this.#scheduled = true;
+  }
+  /**
+  * Schedule the task to run and wait for it to finish.
+  */
+  async runBlocking() {
+    if (this.#ctx?.disposed) {
+      throw new ContextDisposedError2();
+    }
+    this.schedule();
+    await this.#nextTask.wait();
+  }
+  /**
+  * Waits for the current task to finish if it is running.
+  * Does not schedule a new task.
+  */
+  async join() {
+    await this.#currentTask;
+  }
+};
 var runInContext = (ctx, fn) => {
   try {
     fn();
@@ -1447,13 +1540,11 @@ var untilError = (cb) => {
 // src/timer.ts
 var Timer = class {
   _callback;
-  _state;
+  _state = new Event();
   _timer;
-  _count;
+  _count = 0;
   constructor(_callback) {
     this._callback = _callback;
-    this._state = new Event();
-    this._count = 0;
   }
   get state() {
     return this._state;
@@ -1506,16 +1597,13 @@ var UpdateScheduler = class {
   * Promise that resolves when the callback is done.
   * Never rejects.
   */
-  _promise;
-  _scheduled;
-  _lastUpdateTime;
+  _promise = null;
+  _scheduled = false;
+  _lastUpdateTime = -TIME_PERIOD;
   constructor(_ctx, _callback, _params = {}) {
     this._ctx = _ctx;
     this._callback = _callback;
     this._params = _params;
-    this._promise = null;
-    this._scheduled = false;
-    this._lastUpdateTime = -TIME_PERIOD;
     _ctx.onDispose(async () => {
       await this._promise;
     });
@@ -1528,13 +1616,13 @@ var UpdateScheduler = class {
       await this._promise;
       if (this._params.maxFrequency) {
         const now = performance.now();
-        const delay = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
-        if (delay > 0) {
+        const delay2 = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
+        if (delay2 > 0) {
           await new Promise((resolve) => {
             const timeoutId = setTimeout(() => {
               clearContext();
               resolve();
-            }, delay);
+            }, delay2);
             const clearContext = this._ctx.onDispose(() => {
               clearTimeout(timeoutId);
               resolve();
@@ -1578,6 +1666,7 @@ var UpdateScheduler = class {
   }
 };
 export {
+  AsyncTask,
   CancellableObservableProvider,
   DeferredTask,
   Event,
@@ -1604,6 +1693,7 @@ export {
   combine,
   debounce,
   debounceAndThrottle,
+  delay,
   dumpLeaks,
   interval,
   latch,