@dxos/async 0.8.3 → 0.8.4-main.84f28bd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/async",
-  "version": "0.8.3",
+  "version": "0.8.4-main.84f28bd",
   "description": "Async utilities.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -29,12 +29,12 @@
   "dependencies": {
     "zen-observable": "^0.10.0",
     "zen-push": "^0.3.1",
-    "@dxos/debug": "0.8.3",
-    "@dxos/context": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/util": "0.8.3",
-    "@dxos/node-std": "0.8.3"
+    "@dxos/context": "0.8.4-main.84f28bd",
+    "@dxos/debug": "0.8.4-main.84f28bd",
+    "@dxos/invariant": "0.8.4-main.84f28bd",
+    "@dxos/log": "0.8.4-main.84f28bd",
+    "@dxos/node-std": "0.8.4-main.84f28bd",
+    "@dxos/util": "0.8.4-main.84f28bd"
   },
   "devDependencies": {
     "@types/zen-observable": "^0.8.3"

package/src/debounce.test.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { debounce } from './debounce';
+import { sleep } from './timeout';
+
+describe('debounce', () => {
+  test('debounces function calls', async () => {
+    let count = 0;
+    const fn = debounce(() => count++, 100);
+
+    // First call should not execute immediately
+    fn();
+    expect(count).toBe(0);
+
+    // Second call should reset the timer
+    fn();
+    expect(count).toBe(0);
+
+    // Wait for debounce window to pass
+    await sleep(150);
+    expect(count).toBe(1); // Only the last call should execute
+  });
+
+  test('passes arguments to debounced function', async () => {
+    let lastArgs: any[] = [];
+    const fn = debounce((...args: any[]) => {
+      lastArgs = args;
+    }, 100);
+
+    fn('test', 123);
+    expect(lastArgs).toEqual([]); // Should not execute immediately
+
+    // Call with different args
+    fn('different', 456);
+    expect(lastArgs).toEqual([]); // Should not execute immediately
+
+    await sleep(150);
+    expect(lastArgs).toEqual(['different', 456]); // Should execute with last args
+  });
+
+  test('handles multiple rapid calls', async () => {
+    let count = 0;
+    const fn = debounce(() => count++, 100);
+
+    // Make multiple rapid calls
+    for (let i = 0; i < 5; i++) {
+      fn();
+    }
+    expect(count).toBe(0); // Should not execute immediately
+
+    await sleep(150);
+    expect(count).toBe(1); // Should execute only once after wait
+  });
+});

package/src/debounce.ts

@@ -2,6 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+import { throttle } from './throttle';
+
 /**
  * Debounce callback.
  */
@@ -12,3 +14,16 @@ export const debounce = (cb: (...args: any[]) => void, wait = 100): ((...args: a
     t = setTimeout(() => cb(...args), wait);
   };
 };
+
+/**
+ * Debounce and throttle callback.
+ */
+export const debounceAndThrottle = (cb: (...args: any[]) => void, wait = 100): ((...args: any[]) => void) => {
+  const debounced = debounce(cb, wait);
+  const throttled = throttle(cb, wait);
+
+  return (...args: any[]) => {
+    debounced(...args);
+    throttled(...args);
+  };
+};

package/src/events.test.ts

@@ -22,7 +22,7 @@ describe('Event', () => {
       pureCount++;
     });
 
-    const debounced = event.debounce(80);
+    const debounced = event.debounce(200);
     debounced.on(() => {
       debounceCount++;
     });

package/src/index.ts

@@ -20,6 +20,7 @@ export * from './stream-to-array';
 export * from './task-scheduling';
 export * from './test-stream';
 export * from './testing';
+export * from './throttle';
 export * from './timeout';
 export * from './timer';
 export * from './track-leaks';

package/src/throttle.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { throttle } from './throttle';
+import { sleep } from './timeout';
+
+describe('throttle', () => {
+  test('throttles function calls', async () => {
+    let count = 0;
+    const fn = throttle(() => count++, 100);
+
+    // First call should execute immediately
+    fn();
+    expect(count).toBe(1);
+
+    // Second call within throttle window should not execute
+    fn();
+    expect(count).toBe(1);
+
+    // Wait for throttle window to pass
+    await sleep(150);
+
+    // Next call should execute
+    fn();
+    expect(count).toBe(2);
+  });
+
+  test('passes arguments to throttled function', async () => {
+    let lastArgs: any[] = [];
+    const fn = throttle((...args: any[]) => {
+      lastArgs = args;
+    }, 100);
+
+    fn('test', 123);
+    expect(lastArgs).toEqual(['test', 123]);
+
+    // Call with different args within throttle window
+    fn('different', 456);
+    expect(lastArgs).toEqual(['test', 123]); // Should not update
+
+    await sleep(150);
+    fn('new', 789);
+    expect(lastArgs).toEqual(['new', 789]);
+  });
+
+  test('handles multiple rapid calls', async () => {
+    let count = 0;
+    const fn = throttle(() => count++, 100);
+
+    // Make multiple rapid calls
+    for (let i = 0; i < 5; i++) {
+      fn();
+    }
+    expect(count).toBe(1); // Only first call should execute
+
+    await sleep(150);
+    expect(count).toBe(1); // Still only one execution
+
+    fn();
+    expect(count).toBe(2); // Next call after wait should execute
+  });
+});

package/src/throttle.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const throttle = (cb: (...args: any[]) => void, wait = 100): ((...args: any[]) => void) => {
+  let lastCall = 0;
+  return (...args: any[]) => {
+    const now = Date.now();
+    if (now - lastCall >= wait) {
+      cb(...args);
+      lastCall = now;
+    }
+  };
+};