@dxos/async 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/async",
-  "version": "0.8.4-main.7ace549",
+  "version": "0.8.4-main.937b3ca",
   "description": "Async utilities.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
   "sideEffects": true,
@@ -29,12 +33,12 @@
   "dependencies": {
     "zen-observable": "^0.10.0",
     "zen-push": "^0.3.1",
-    "@dxos/context": "0.8.4-main.7ace549",
-    "@dxos/debug": "0.8.4-main.7ace549",
-    "@dxos/invariant": "0.8.4-main.7ace549",
-    "@dxos/log": "0.8.4-main.7ace549",
-    "@dxos/util": "0.8.4-main.7ace549",
-    "@dxos/node-std": "0.8.4-main.7ace549"
+    "@dxos/context": "0.8.4-main.937b3ca",
+    "@dxos/debug": "0.8.4-main.937b3ca",
+    "@dxos/log": "0.8.4-main.937b3ca",
+    "@dxos/node-std": "0.8.4-main.937b3ca",
+    "@dxos/util": "0.8.4-main.937b3ca",
+    "@dxos/invariant": "0.8.4-main.937b3ca"
   },
   "devDependencies": {
     "@types/zen-observable": "^0.8.3"

package/src/cleanup.ts

@@ -37,6 +37,7 @@ type EventMap<T> = T extends Window
 /**
  * Add the event listener and return a cleanup function.
  * Can be used in effect hooks in conjunction with `combine`.
+ * @deprecated use bind-event-listener
  */
 export const addEventListener = <T extends EventTarget, K extends keyof EventMap<T>>(
   target: T,

package/src/persistent-lifecycle.ts

@@ -13,7 +13,7 @@ import { sleep } from './timeout';
 const INIT_RESTART_DELAY = 100;
 const DEFAULT_MAX_RESTART_DELAY = 5000;
 
-export type PersistentLifecycleParams<T> = {
+export type PersistentLifecycleProps<T> = {
   /**
    * Create connection.
    * If promise resolves successfully, connection is considered established.
@@ -51,7 +51,7 @@ export class PersistentLifecycle<T> extends Resource {
   private _restartTask?: DeferredTask = undefined;
   private _restartAfter = 0;
 
-  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleParams<T>) {
+  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleProps<T>) {
     super();
     this._start = start;
     this._stop = stop;

package/src/task-scheduling.ts

@@ -77,6 +77,99 @@ export class DeferredTask {
   }
 }
 
+// TODO(dmaretskyi): Protyping this an alternative API to DeferredTask.
+export class AsyncTask {
+  #callback: () => Promise<void>;
+  #ctx?: Context = undefined;
+
+  #scheduled = false;
+  #currentTask: Promise<void> | null = null; // Can't be rejected.
+  #nextTask = new Trigger();
+
+  constructor(callback: () => Promise<void>) {
+    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: Context): void {
+    this.#ctx = ctx;
+  }
+
+  /**
+   * Closes the task and waits for it to finish if it is running.
+   */
+  async close(): Promise<void> {
+    this.#ctx = undefined;
+    await this.join();
+  }
+
+  [Symbol.asyncDispose](): Promise<void> {
+    return this.close();
+  }
+
+  /**
+   * Schedule the task to run asynchronously.
+   */
+  schedule(): void {
+    if (!this.#ctx || this.#ctx.disposed) {
+      throw new Error('AsyncTask not open');
+    }
+
+    if (this.#scheduled) {
+      return; // Already scheduled.
+    }
+
+    scheduleTask(this.#ctx, async () => {
+      // The previous task might still be running, so we need to wait for it to finish.
+      await this.#currentTask; // Can't be rejected.
+
+      if (!this.#ctx || this.#ctx.disposed) {
+        return;
+      }
+
+      // Reset the flag. New tasks can now be scheduled. They would wait for the callback to finish.
+      this.#scheduled = false;
+      const completionTrigger = this.#nextTask;
+      this.#nextTask = new Trigger(); // Re-create the trigger as opposed to resetting it since there might be listeners waiting for it.
+
+      // Store the promise so that new tasks could wait for this one to finish.
+      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(): Promise<void> {
+    if (this.#ctx?.disposed) {
+      throw new ContextDisposedError();
+    }
+
+    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(): Promise<void> {
+    await this.#currentTask;
+  }
+}
+
 export const runInContext = (ctx: Context, fn: () => void) => {
   try {
     fn();