@dxos/async 0.8.3 → 0.8.4-main.1068cf700f

package/src/timeout.ts

@@ -4,7 +4,7 @@
 
 import { type Context, ContextDisposedError } from '@dxos/context';
 
-import { createPromiseFromCallback } from './callback';
+import { promiseFromCallback } from './callback';
 import { TimeoutError } from './errors';
 
 /**
@@ -28,6 +28,27 @@ export const sleep = (ms: number) => {
   });
 };
 
+// TODO(burdon): Reconcile with sleep.
+export const sleepWithContext = (ctx: Context, ms: number) => {
+  const error = new ContextDisposedError();
+  return new Promise<void>((resolve, reject) => {
+    if (ctx.disposed) {
+      reject(error);
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      clearDispose();
+      resolve();
+    }, ms);
+
+    const clearDispose = ctx.onDispose(() => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+};
+
 /**
  * Can be used in long-running tasks to let other callbacks be invoked.
  */
@@ -52,7 +73,7 @@ export const asyncTimeout = async <T>(
     unrefTimeout(timeoutId);
   });
 
-  const conditionTimeout = typeof promise === 'function' ? createPromiseFromCallback<T>(promise) : promise;
+  const conditionTimeout = typeof promise === 'function' ? promiseFromCallback<T>(promise) : promise;
   return await Promise.race([conditionTimeout, timeoutPromise]).finally(() => {
     clearTimeout(timeoutId);
   });
@@ -67,23 +88,3 @@ export const unrefTimeout = (timeoutId: NodeJS.Timeout) => {
     timeoutId.unref();
   }
 };
-
-export const sleepWithContext = (ctx: Context, ms: number) => {
-  const error = new ContextDisposedError();
-  return new Promise<void>((resolve, reject) => {
-    if (ctx.disposed) {
-      reject(error);
-      return;
-    }
-
-    const timeout = setTimeout(() => {
-      clearDispose();
-      resolve();
-    }, ms);
-
-    const clearDispose = ctx.onDispose(() => {
-      clearTimeout(timeout);
-      reject(error);
-    });
-  });
-};

package/src/trigger.ts

@@ -2,6 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
+import { invariant } from '@dxos/invariant';
+
 import { TimeoutError } from './errors';
 import { asyncTimeout } from './timeout';
 
@@ -10,7 +12,7 @@ import { asyncTimeout } from './timeout';
  * @deprecated Use `Trigger` instead.
  */
 export const trigger = <T = void>(timeout?: number): [() => Promise<T>, (arg: T) => void] => {
-  // eslint-disable-line @stayradiated/prefer-arrow-functions/prefer-arrow-functions
+  // eslint-disable-line prefer-arrow-functions/prefer-arrow-functions
   let callback: (arg: T) => void;
 
   const promise = new Promise<T>((resolve, reject) => {
@@ -121,3 +123,58 @@ export class Trigger<T = void> {
     return this;
   }
 }
+
+type LatchProps = {
+  count?: number;
+  timeout?: number;
+};
+
+type LatchResult = [() => Promise<number>, () => number, (err: Error) => void];
+
+/**
+ * Returns a callback and a promise that's resolved when the callback is called n times.
+ * @deprecated Use `Trigger` instead.
+ */
+export const latch = ({ count = 1, timeout }: LatchProps = {}): LatchResult => {
+  invariant(count >= 0);
+
+  let t: ReturnType<typeof setTimeout>;
+  let doResolve: (value: number) => void;
+  let doReject: (err: Error) => void;
+  const promise = new Promise<number>((resolve, reject) => {
+    doResolve = (value) => {
+      clearTimeout(t);
+      resolve(value);
+    };
+
+    doReject = (err) => {
+      clearTimeout(t);
+      reject(err);
+    };
+  });
+
+  if (count === 0) {
+    setTimeout(() => {
+      doResolve(0);
+    });
+  } else {
+    if (timeout) {
+      t = setTimeout(() => {
+        doReject(new Error(`Timed out after ${timeout.toLocaleString()}ms`));
+      }, timeout);
+    }
+  }
+
+  let i = 0;
+  return [
+    async () => await promise,
+    () => {
+      if (++i === count) {
+        doResolve(i);
+      }
+
+      return i;
+    },
+    (err: Error) => doReject(err),
+  ];
+};

package/src/update-scheduler.ts

@@ -16,7 +16,7 @@ export type UpdateSchedulerOptions = {
 /**
  * Time period for update counting.
  */
-const TIME_PERIOD = 1000;
+const TIME_PERIOD = 1_000;
 
 export class UpdateScheduler {
   /**