@cjser/p-debounce 5.1.0-cjser.2

package/dist-cjser/index.cjs

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/@cjser/p-debounce/index.js
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var pDebounce = (functionToDebounce, wait, options = {}) => {
+  if (!Number.isFinite(wait)) {
+    throw new TypeError("Expected `wait` to be a finite number");
+  }
+  let leadingValue;
+  let timeout;
+  let promiseHandlers = [];
+  const onAbort = () => {
+    var _a;
+    clearTimeout(timeout);
+    timeout = void 0;
+    try {
+      (_a = options.signal) == null ? void 0 : _a.throwIfAborted();
+    } catch (error) {
+      for (const { reject } of promiseHandlers) {
+        reject(error);
+      }
+      promiseHandlers = [];
+    }
+  };
+  return function(...arguments_) {
+    return new Promise((resolve, reject) => {
+      var _a;
+      try {
+        (_a = options.signal) == null ? void 0 : _a.throwIfAborted();
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      const shouldCallNow = options.before && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(async () => {
+        var _a2;
+        timeout = void 0;
+        const currentHandlers = promiseHandlers;
+        promiseHandlers = [];
+        try {
+          const result = options.before ? leadingValue : await functionToDebounce.apply(this, arguments_);
+          for (const { resolve: resolveFunction } of currentHandlers) {
+            resolveFunction(result);
+          }
+        } catch (error) {
+          for (const { reject: rejectFunction } of currentHandlers) {
+            rejectFunction(error);
+          }
+        }
+        leadingValue = void 0;
+        (_a2 = options.signal) == null ? void 0 : _a2.removeEventListener("abort", onAbort);
+      }, wait);
+      if (shouldCallNow) {
+        (async () => {
+          try {
+            leadingValue = await functionToDebounce.apply(this, arguments_);
+            resolve(leadingValue);
+          } catch (error) {
+            reject(error);
+          }
+        })();
+      } else {
+        promiseHandlers.push({ resolve, reject });
+        if (options.signal && promiseHandlers.length === 1) {
+          options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+      }
+    });
+  };
+};
+pDebounce.promise = (function_, options = {}) => {
+  let currentPromise;
+  let queuedCall;
+  return async function(...arguments_) {
+    if (currentPromise) {
+      if (!options.after) {
+        return currentPromise;
+      }
+      queuedCall ??= { resolvers: [] };
+      queuedCall.arguments = arguments_;
+      queuedCall.context = this;
+      return new Promise((resolve, reject) => {
+        queuedCall.resolvers.push({ resolve, reject });
+      });
+    }
+    currentPromise = (async () => {
+      let result;
+      let initialError;
+      try {
+        result = await function_.apply(this, arguments_);
+      } catch (error) {
+        initialError = error;
+      }
+      while (queuedCall) {
+        const call = queuedCall;
+        queuedCall = void 0;
+        try {
+          const queuedResult = await function_.apply(call.context, call.arguments);
+          for (const { resolve } of call.resolvers) {
+            resolve(queuedResult);
+          }
+        } catch (error) {
+          for (const { reject } of call.resolvers) {
+            reject(error);
+          }
+        }
+      }
+      if (initialError) {
+        throw initialError;
+      }
+      return result;
+    })();
+    try {
+      return await currentPromise;
+    } finally {
+      currentPromise = void 0;
+    }
+  };
+};
+var index_default = pDebounce;

package/index.d.ts

@@ -0,0 +1,113 @@
+export type Options = {
+	/**
+	Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1). Meaning immediately, instead of waiting for `wait` milliseconds.
+
+	@default false
+	*/
+	readonly before?: boolean;
+
+	/**
+	An `AbortSignal` to cancel the debounced function.
+	*/
+	readonly signal?: AbortSignal;
+};
+
+export type PromiseOptions = {
+	/**
+	If a call is made while a previous call is still running, queue the latest arguments and run the function again after the current execution completes.
+
+	@default false
+
+	Use cases:
+	- With `after: false` (default): API fetches, data loading, read operations - concurrent calls share the same result.
+	- With `after: true`: Saving data, file writes, state updates - ensures latest data is never lost.
+
+	@example
+	```
+	import {setTimeout as delay} from 'timers/promises';
+	import pDebounce from '@cjser/p-debounce';
+
+	const save = async data => {
+		await delay(200);
+		console.log(`Saved: ${data}`);
+		return data;
+	};
+
+	const debouncedSave = pDebounce.promise(save, {after: true});
+
+	// If data changes while saving, it will save again with the latest data
+	debouncedSave('data1');
+	debouncedSave('data2'); // This will run after the first save completes
+	//=> Saved: data1
+	//=> Saved: data2
+	```
+	*/
+	readonly after?: boolean;
+};
+
+declare const pDebounce: {
+	/**
+	[Debounce](https://css-tricks.com/debouncing-throttling-explained-examples/) promise-returning & async functions.
+
+	@param fn - Promise-returning/async function to debounce.
+	@param wait - Milliseconds to wait before calling `fn`.
+	@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+
+	@example
+	```
+	import pDebounce from '@cjser/p-debounce';
+
+	const expensiveCall = async input => input;
+
+	const debouncedFunction = pDebounce(expensiveCall, 200);
+
+	for (const number of [1, 2, 3]) {
+		(async () => {
+			console.log(await debouncedFunction(number));
+		})();
+	}
+	//=> 3
+	//=> 3
+	//=> 3
+	```
+	*/
+	<This, ArgumentsType extends unknown[], ReturnType>(
+		fn: (this: This, ...arguments: ArgumentsType) => PromiseLike<ReturnType> | ReturnType,
+		wait: number,
+		options?: Options
+	): (this: This, ...arguments: ArgumentsType) => Promise<ReturnType>;
+
+	/**
+	Execute `function_` unless a previous call is still pending, in which case, return the pending promise. Useful, for example, to avoid processing extra button clicks if the previous one is not complete.
+
+	@param function_ - Promise-returning/async function to debounce.
+
+	@example
+	```
+	import {setTimeout as delay} from 'timers/promises';
+	import pDebounce from '@cjser/p-debounce';
+
+	const expensiveCall = async value => {
+		await delay(200);
+		return value;
+	};
+
+	const debouncedFunction = pDebounce.promise(expensiveCall);
+
+	for (const number of [1, 2, 3]) {
+		(async () => {
+			console.log(await debouncedFunction(number));
+		})();
+	}
+	//=> 1
+	//=> 1
+	//=> 1
+	```
+	*/
+	promise<This, ArgumentsType extends unknown[], ReturnType>(
+		function_: (this: This, ...arguments: ArgumentsType) => PromiseLike<ReturnType> | ReturnType,
+		options?: PromiseOptions
+	): (this: This, ...arguments: ArgumentsType) => Promise<ReturnType>;
+};
+
+export default pDebounce;

package/index.js

@@ -0,0 +1,153 @@
+const pDebounce = (functionToDebounce, wait, options = {}) => {
+	if (!Number.isFinite(wait)) {
+		throw new TypeError('Expected `wait` to be a finite number');
+	}
+
+	let leadingValue;
+	let timeout;
+	let promiseHandlers = []; // Single array of {resolve, reject}
+
+	const onAbort = () => {
+		clearTimeout(timeout);
+		timeout = undefined;
+
+		try {
+			options.signal?.throwIfAborted();
+		} catch (error) {
+			for (const {reject} of promiseHandlers) {
+				reject(error);
+			}
+
+			promiseHandlers = [];
+		}
+	};
+
+	return function (...arguments_) {
+		return new Promise((resolve, reject) => {
+			// Check if already aborted
+			try {
+				options.signal?.throwIfAborted();
+			} catch (error) {
+				reject(error);
+				return;
+			}
+
+			const shouldCallNow = options.before && !timeout;
+
+			clearTimeout(timeout);
+
+			timeout = setTimeout(async () => {
+				timeout = undefined;
+
+				// Capture the current handlers for this execution
+				const currentHandlers = promiseHandlers;
+
+				// Clear handlers for next cycle (new calls during execution will add to new list)
+				promiseHandlers = [];
+
+				try {
+					const result = options.before ? leadingValue : await functionToDebounce.apply(this, arguments_);
+
+					for (const {resolve: resolveFunction} of currentHandlers) {
+						resolveFunction(result);
+					}
+				} catch (error) {
+					for (const {reject: rejectFunction} of currentHandlers) {
+						rejectFunction(error);
+					}
+				}
+
+				// Clear leading value for next cycle
+				leadingValue = undefined;
+
+				// Remove abort listener
+				options.signal?.removeEventListener('abort', onAbort);
+			}, wait);
+
+			if (shouldCallNow) {
+				// Execute immediately for leading edge
+				(async () => {
+					try {
+						leadingValue = await functionToDebounce.apply(this, arguments_);
+						resolve(leadingValue);
+					} catch (error) {
+						reject(error);
+					}
+				})();
+			} else {
+				// Add to handlers for later resolution
+				promiseHandlers.push({resolve, reject});
+
+				// Set up abort listener (only once per batch)
+				if (options.signal && promiseHandlers.length === 1) {
+					options.signal.addEventListener('abort', onAbort, {once: true});
+				}
+			}
+		});
+	};
+};
+
+pDebounce.promise = (function_, options = {}) => {
+	let currentPromise;
+	let queuedCall;
+
+	return async function (...arguments_) {
+		if (currentPromise) {
+			if (!options.after) {
+				return currentPromise;
+			}
+
+			// Queue latest call (replacing any existing queue)
+			queuedCall ??= {resolvers: []};
+			queuedCall.arguments = arguments_;
+			queuedCall.context = this;
+
+			return new Promise((resolve, reject) => {
+				queuedCall.resolvers.push({resolve, reject});
+			});
+		}
+
+		currentPromise = (async () => {
+			let result;
+			let initialError;
+
+			try {
+				result = await function_.apply(this, arguments_);
+			} catch (error) {
+				initialError = error;
+			}
+
+			// Process queued calls regardless of initial result
+			while (queuedCall) {
+				const call = queuedCall;
+				queuedCall = undefined;
+
+				try {
+					// eslint-disable-next-line no-await-in-loop
+					const queuedResult = await function_.apply(call.context, call.arguments);
+					for (const {resolve} of call.resolvers) {
+						resolve(queuedResult);
+					}
+				} catch (error) {
+					for (const {reject} of call.resolvers) {
+						reject(error);
+					}
+				}
+			}
+
+			if (initialError) {
+				throw initialError;
+			}
+
+			return result;
+		})();
+
+		try {
+			return await currentPromise;
+		} finally {
+			currentPromise = undefined;
+		}
+	};
+};
+
+export default pDebounce;

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@cjser/p-debounce",
+  "version": "5.1.0-cjser.2",
+  "description": "Debounce promise-returning & async functions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://code.moenext.com/3rdeye/cjser.git"
+  },
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "require": "./dist-cjser/index.cjs",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "xo && node --test && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "dist-cjser"
+  ],
+  "keywords": [
+    "promise",
+    "debounce",
+    "debounced",
+    "limit",
+    "limited",
+    "concurrency",
+    "throttle",
+    "throat",
+    "interval",
+    "rate",
+    "batch",
+    "ratelimit",
+    "task",
+    "queue",
+    "async",
+    "await",
+    "promises",
+    "bluebird"
+  ],
+  "devDependencies": {
+    "tsd": "^0.33.0",
+    "xo": "^1.2.2"
+  },
+  "types": "./index.d.ts",
+  "main": "./dist-cjser/index.cjs",
+  "cjser": {
+    "sourceVersion": "5.1.0",
+    "cjserVersion": 2,
+    "original": {
+      "name": "p-debounce",
+      "version": "5.1.0",
+      "exports": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "repository": "sindresorhus/p-debounce",
+      "files": [
+        "index.js",
+        "index.d.ts"
+      ],
+      "scripts": {
+        "test": "xo && node --test && tsd"
+      }
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,141 @@
+# p-debounce
+
+> [Debounce](https://css-tricks.com/debouncing-throttling-explained-examples/) promise-returning & async functions
+
+## Install
+
+```sh
+npm install p-debounce
+```
+
+## Usage
+
+```js
+import pDebounce from 'p-debounce';
+
+const expensiveCall = async input => input;
+
+const debouncedFunction = pDebounce(expensiveCall, 200);
+
+for (const number of [1, 2, 3]) {
+	(async () => {
+		console.log(await debouncedFunction(number));
+	})();
+}
+//=> 3
+//=> 3
+//=> 3
+```
+
+## API
+
+### pDebounce(fn, wait, options?)
+
+Returns a function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+
+#### fn
+
+Type: `Function`
+
+Promise-returning/async function to debounce.
+
+#### wait
+
+Type: `number`
+
+Milliseconds to wait before calling `fn`.
+
+#### options
+
+Type: `object`
+
+##### before
+
+Type: `boolean`\
+Default: `false`
+
+Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1). Meaning immediately, instead of waiting for `wait` milliseconds.
+
+##### signal
+
+Type: `AbortSignal`
+
+An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) to cancel the debounced function.
+
+### pDebounce.promise(function_, options?)
+
+Execute `function_` unless a previous call is still pending, in which case, return the pending promise. Useful, for example, to avoid processing extra button clicks if the previous one is not complete.
+
+```js
+import {setTimeout as delay} from 'timers/promises';
+import pDebounce from 'p-debounce';
+
+const expensiveCall = async value => {
+	await delay(200);
+	return value;
+};
+
+const debouncedFunction = pDebounce.promise(expensiveCall);
+
+for (const number of [1, 2, 3]) {
+	(async () => {
+		console.log(await debouncedFunction(number));
+	})();
+}
+//=> 1
+//=> 1
+//=> 1
+```
+
+#### function_
+
+Type: `Function`
+
+Promise-returning/async function to debounce.
+
+#### options
+
+Type: `object`
+
+##### after
+
+Type: `boolean`\
+Default: `false`
+
+If a call is made while a previous call is still running, queue the latest arguments and run the function again after the current execution completes.
+
+Use cases:
+- With `after: false` (default): API fetches, data loading, read operations - concurrent calls share the same result.
+- With `after: true`: Saving data, file writes, state updates - ensures latest data is never lost.
+
+```js
+import {setTimeout as delay} from 'timers/promises';
+import pDebounce from 'p-debounce';
+
+const save = async data => {
+	await delay(200);
+	console.log(`Saved: ${data}`);
+	return data;
+};
+
+const debouncedSave = pDebounce.promise(save, {after: true});
+
+// If data changes while saving, it will save again with the latest data
+debouncedSave('data1');
+debouncedSave('data2'); // This will run after the first save completes
+//=> Saved: data1
+//=> Saved: data2
+```
+
+## Related
+
+- [p-throttle](https://github.com/sindresorhus/p-throttle) - Throttle promise-returning & async functions
+- [p-limit](https://github.com/sindresorhus/p-limit) - Run multiple promise-returning & async functions with limited concurrency
+- [p-memoize](https://github.com/sindresorhus/p-memoize) - Memoize promise-returning & async functions
+- [debounce-fn](https://github.com/sindresorhus/debounce-fn) - Debounce a function
+- [More…](https://github.com/sindresorhus/promise-fun)
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/sindresorhus/p-debounce