@superutils/core 1.1.5 → 1.1.6

package/README.md

@@ -13,8 +13,9 @@ For full API reference check out the [docs page](https://alien45.github.io/super
 - [Installation](#installation)
 - [Usage](#usage)
     - [`is`](#is): Type checkers
-    - [`deferred()`](#deferred): Debounce callbacks
+    - [`debounce()`](#debounce): Debounce callbacks
     - [`throttle()`](#throttle): Throttle callbacks
+    - [`deferred()`](#deferred): Debounce/Throttle callbacks
     - [`fallbackIfFails()`](#fallback-if-fails): Gracefully invoke functions or promises with a fallback
     - [`objCopy()`](#obj-copy): Deep-copy objects
     - [`search()`](#search): Search iterable collections
@@ -76,27 +77,29 @@ import {
 } from '@superutils/core'
 ```
 
-<div id="deferred"></div>
-
-### `deferred(fn)`: debounce callbacks
+<div id="debouce"></div>
 
-`debounce()`, a sugar for `deferred()`, is also available.
+### `debouce(fn, delay, options)`: debounce callbacks
 
 ```javascript
-import { deferred } from '@superutils/core'
+import { debouce } from '@superutils/core'
 
-const handleChange = deferred(
+const handleChange = debouce(
 	event => console.log(event.target.value),
 	300, // debounce delay in milliseconds
+	{
+		leading: false, // default
+	},
 )
-handleChange({ target: { value: 1 } }) // will be ignored
+handleChange({ target: { value: 1 } }) // will be ignored, unless `leading = true`
 handleChange({ target: { value: 2 } }) // will be ignored
-handleChange({ target: { value: 3 } }) // will be executed
+handleChange({ target: { value: 3 } }) // will be ignored
+handleChange({ target: { value: 4 } }) // will be executed
 ```
 
 <div id="throttle"></div>
 
-### `throttle(fn)`: throttle callbacks
+### `throttle(fn, delay, options)`: throttle callbacks
 
 ```javascript
 import { throttle } from '@superutils/core'
@@ -104,10 +107,33 @@ import { throttle } from '@superutils/core'
 const handleChange = throttle(
 	event => console.log(event.target.value),
 	300, // throttle duration in milliseconds
+	{
+		trailing: false, // default
+	},
 )
 handleChange({ target: { value: 1 } }) // will be executed
 handleChange({ target: { value: 2 } }) // will be ignored
 handleChange({ target: { value: 3 } }) // will be ignored
+handleChange({ target: { value: 4 } }) // will be ignored, unless `trailing = true`
+```
+
+<div id="deferred"></div>
+
+### `deferred(fn, delay, options)`: debounce/throttle callbacks
+
+Create debounced/throttled functions using the `throttle` switch.
+
+```javascript
+import { deferred } from '@superutils/core'
+
+const handleChange = deferred(
+	event => console.log(event.target.value),
+	300, // delay in milliseconds
+	{ throttle: false }, // determines whether to create a debounced or throttled function
+)
+handleChange({ target: { value: 1 } }) // will be ignored
+handleChange({ target: { value: 2 } }) // will be ignored
+handleChange({ target: { value: 3 } }) // will be executed
 ```
 
 <div id="fallback-if-fails"></div>

package/dist/index.d.ts

@@ -28,15 +28,6 @@ type CurriedArgs<TArgs extends unknown[], TArgsIsFinite extends boolean, TFunc e
     ...KeepRequired<TArgs>,
     ...KeepOptionals<TArgs, true, undefined>
 ], TArity>;
-/**
- * Deferred function options
- */
-type DeferredOptions<ThisArg = unknown> = {
-    leading?: boolean | 'global';
-    onError?: (err: unknown) => ValueOrPromise<unknown>;
-    thisArg?: ThisArg;
-    tid?: TimeoutId;
-};
 /**
  * Drop the first item from an array/tuple and keep the rest
  * ---
@@ -67,6 +58,13 @@ type DropFirstN<T extends unknown[], N extends number, Dropped extends unknown[]
  * ```
  */
 type DropLast<T extends unknown[]> = T extends [...infer Rest, unknown] ? Rest : [];
+/**
+ * If `T` is a promise turn it into an union type by adding the value type
+ */
+type IfPromiseAddValue<T> = T extends Promise<infer V> ? T | V : T;
+/**
+ * Check if a tuple/array has a finite length
+ */
 type IsFiniteTuple<T extends unknown[]> = number extends T['length'] ? false : true;
 type IsOptional<T, K extends keyof T> = {} extends Pick<T, K> ? true : false;
 /**
@@ -188,7 +186,10 @@ type TupleWithAlt<Tuple extends unknown[], TAlt = undefined> = {
  * ```
  */
 type ValueOrFunc<Value, Args extends unknown[] = []> = Value | ((...args: Args) => Value);
-/** Accept value a promise resolving to value */
+/**
+ * Represents a value that can be either a direct value of type `T` or a `Promise` that resolves to `T`.
+ * This is useful for functions that can handle both synchronous and asynchronous results.
+ */
 type ValueOrPromise<T> = T | Promise<T>;
 
 /**
@@ -254,61 +255,6 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
     arity: TArity
 ]): Curry<TData, CurriedArgs<TArgs, TArgsIsFinite, (...args: TArgs) => TData, TArity>>;
 
-/**
- *
- * Returns a function that invokes the callback function after certain delay/timeout.
- * All errors will be gracefully swallowed.
- *
- * @param	callback 	function to be invoked after timeout
- * @param	delay		(optional) timeout duration in milliseconds. Default: 50
- * @param   config.onError (optional)
- * @param   config.leading (optional) if true, will enable leading-edge debounce mechanism.
- * @param   config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
- * @param	config.tid	   (optional) Timeout Id. If provided, will clear the timeout on first invocation.
- *
- * @example Debounce function calls
- * ```javascript
- * import { deferred } from '@superutils/core'
- *
- * const handleChange = deferred(
- *     event => console.log('Value:', event.target.value),
- *     300 // debounce delay in milliseconds
- * )
- *
- * handleChange({ target: { value: 1 } }) // will be ignored
- * handleChange({ target: { value: 2 } }) // will be ingored
- * handleChange({ target: { value: 3 } }) // will be invoked
- * ```
- */
-declare const deferred: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DeferredOptions<ThisArg>): (...args: TArgs) => void;
-    defaults: {
-        /**
-         * Set the default value of argument `leading` for the `deferred` function.
-         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-         */
-        leading: false;
-        /**
-         * Set the default value of argument `onError` for the `deferred` function.
-         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-         */
-        onError: undefined;
-    };
-};
-
-/** Super for `deferred()` function */
-declare const debounce: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DeferredOptions<ThisArg>): (...args: TArgs) => void;
-    defaults: {
-        leading: false;
-        onError: undefined;
-    };
-};
-
-/**
- * If `T` is a promise turn it into an union type by adding the value type
- */
-type IfPromiseAddValue<T> = T extends Promise<infer V> ? T | V : T;
 /**
  * @function fallbackIfFails
  * @summary a flexible try-catch wrapper for invoking functions and ignore errors gracefully.
@@ -684,48 +630,6 @@ declare const is: {
 declare function noop(): void;
 declare function noopAsync(): Promise<void>;
 
-type ThrottleOptions<ThisArg = unknown> = {
-    onError?: (err: unknown) => ValueOrPromise<unknown>;
-    thisArg?: ThisArg;
-    trailing?: boolean;
-    tid?: TimeoutId;
-};
-/**
- * @function throttle
- * @summary returns a function that invokes the `callback` maximum twice (once if `executeLast = false`) per interval
- *
- * @param	callback function to be invoked after timeout
- * @param	delay	 (optional) interval duration in milliseconds. Default: 50
- * @param   config.onError  (optional)
- * @param   config.tid      (optional)
- * @param	config.thisArg  (optional) the special `thisArgs` to be used when invoking the callback.
- * @param   config.trailing (optional) whether to enable trailing edge execution. Default: `true`
- *
- * @example
- * ```javascript
- * import { throttle } from '@superutils/core'
- *
- * const handleChange = throttle(
- *     event => console.log('Value:', event.target.value),
- *     300, // throttle duration in milliseconds
- * )
- * handleChange({ target: { value: 1 } }) // will be executed
- * handleChange({ target: { value: 2 } }) // will be ignored
- * handleChange({ target: { value: 3 } }) // will be ignored
- * ```
- */
-declare const throttled: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
-    /**
-     * Set the default values
-     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
-     */
-    defaults: {
-        onError: undefined;
-        trailing: false;
-    };
-};
-
 /**
  * Convert timestamp to `input["datetime-local"]` compatible format.
  *
@@ -974,6 +878,7 @@ declare const arrReverse: <T = unknown>(arr: T[], reverse?: boolean, newArray?:
  * 	   arr,
  * 	   (_: Item, i: number) => item.a,
  * )
+ * ```
  *
  * @example Flatten and convert Array to Map
  * ```typescript
@@ -997,6 +902,173 @@ declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, Map
  */
 declare const arrUnique: <T = unknown>(arr: T[], flatDepth?: number) => FlatArray<T, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -1 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[];
 
+/**
+ * Debounce function options
+ */
+type DebounceOptions<ThisArg = unknown> = {
+    leading?: boolean | 'global';
+    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
+    thisArg?: ThisArg;
+    tid?: TimeoutId;
+};
+/**
+ * Deferred function options
+ */
+type DeferredOptions<ThisArg = unknown> = ({
+    throttle: true;
+} & ThrottleOptions<ThisArg>) | ({
+    throttle?: false;
+} & DebounceOptions<ThisArg>);
+/**
+ * Throttle function options
+ */
+type ThrottleOptions<ThisArg = unknown> = {
+    /**
+     *
+     * @param err Error object thrown by the callback function.
+     * @returns
+     */
+    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
+    thisArg?: ThisArg;
+    trailing?: boolean;
+    tid?: TimeoutId;
+};
+
+/**
+ * Returns a function that invokes the callback function after certain delay/timeout.
+ * All errors will be gracefully swallowed.
+ *
+ * @param	callback 	function to be invoked after timeout
+ * @param	delay		(optional) timeout duration in milliseconds. Default: 50
+ * @param   config.onError (optional)
+ * @param   config.leading (optional) if true, will enable leading-edge debounce mechanism.
+ * @param   config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
+ * @param	config.tid	   (optional) Timeout Id. If provided, will clear the timeout on first invocation.
+ *
+ * @example Debounce function calls
+ * ```javascript
+ * import { deferred } from '@superutils/core'
+ *
+ * const handleChange = deferred(
+ *     event => console.log('Value:', event.target.value),
+ *     300 // debounce delay in milliseconds
+ * )
+ *
+ * handleChange({ target: { value: 1 } }) // will be ignored
+ * handleChange({ target: { value: 2 } }) // will be ingored
+ * handleChange({ target: { value: 3 } }) // will be invoked
+ * ```
+ */
+declare const debounce: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DebounceOptions<ThisArg>): (...args: TArgs) => void;
+    defaults: {
+        /**
+         * Set the default value of argument `leading` for the `deferred` function.
+         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+         */
+        leading: false;
+        /**
+         * Set the default value of argument `onError` for the `deferred` function.
+         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+         */
+        onError: undefined;
+    };
+};
+
+/**
+ * Returns a function that can be used to debounce/throttle calls to the provided callback function.
+ * All errors will be gracefully swallowed. See {@link debounce} and {@link throttle} for more information.
+ *
+ * @param callback function to be invoked after delay
+ * @param delay (optional) delay duration in milliseconds. Default: `50`
+ * @param config (optional) debounce or throttle configuration options
+ *
+ * @returns Callback function that can be invoked in one of the following 2 methods:
+ * - debounced: when `throttle` is `false` or `undefined`
+ * - throttled: when `throttle` is `true`
+ */
+declare const deferred: <TArgs extends unknown[], ThisArg, Delay = unknown>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: Delay, config?: DeferredOptions<ThisArg>) => (...args: TArgs) => void;
+
+/**
+ * Returns a throttled function that ensures the callback is invoked at most once in the specified delay interval.
+ * All errors will be gracefully swallowed.
+ *
+ * If the throttled function is called multiple times during the delay interval, only the first call will invoke the callback immediately.
+ *
+ * If `trailing` is enabled and if returned function is invoked more than once during the delay interval,
+ * the callback runs again at the end of the delay with the most recent arguments.
+ *
+ * @param callback function to be invoked after timeout
+ * @param delay (optional) interval duration in milliseconds. Default: 50
+ * @param config (optional)
+ * @param config.onError (optional) callback to be invoked on error
+ * @param config.tid (optional)
+ * @param config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
+ * @param config.trailing (optional) whether to enable trailing edge execution. Default: `true`
+ *
+ * @example Throttle function calls
+ * ```javascript
+ * import { throttle } from '@superutils/core'
+ *
+ * const handleChange = throttle(
+ *     event => console.log('Value:', event.target.value),
+ *     300, // throttle duration in milliseconds
+ * )
+ * handleChange({ target: { value: 1 } }) // will be executed
+ * handleChange({ target: { value: 2 } }) // will be ignored
+ * handleChange({ target: { value: 3 } }) // will be ignored
+ *
+ * setTimeout(() => {
+ *    handleChange({ target: { value: 4 } }) // will be executed (after 300ms)
+ *    handleChange({ target: { value: 5 } }) // will be ignored
+ * }, 400)
+ * ```
+ *
+ * @example Throttle with trailing enabled
+ * ```javascript
+ * import { throttle } from '@superutils/core'
+ *
+ * const handleChange = throttle(
+ *     event => console.log('Value:', event.target.value),
+ *     300, // throttle duration in milliseconds
+ * )
+ * handleChange({ target: { value: 1 } }) // will be executed
+ * handleChange({ target: { value: 2 } }) // will be ignored
+ * handleChange({ target: { value: 3 } }) //  will be executed
+ *
+ * setTimeout(() => {
+ *    handleChange({ target: { value: 4 } }) // will be executed
+ *    handleChange({ target: { value: 5 } }) // will be ignored
+ * }, 400)
+ * ```
+ */
+declare const throttle: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
+    /**
+     * Set the default values
+     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
+     */
+    defaults: {
+        onError: undefined;
+        trailing: false;
+    };
+};
+/**
+ * For legacy compatibility
+ * @deprecated use `throttle` instead
+ */
+declare const throttled: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
+    /**
+     * Set the default values
+     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
+     */
+    defaults: {
+        onError: undefined;
+        trailing: false;
+    };
+};
+
 /** Configuration for finding {@link IterableList} items */
 type FindOptions<K, V, IncludeKey extends boolean = false> = Omit<SearchOptions<K, V>, 'limit' | 'asMap'> & {
     /**
@@ -1114,7 +1186,7 @@ declare const filter: <K, V, AsArray extends boolean = false, Result = AsArray e
  *
  * @returns first item matched or `undefined` if not found
  *
- * @example Find item using callback
+ * @example Find item using predicate callback
  * ```typescript
  * import { find } from '@superutils/core'
  *
@@ -1486,4 +1558,4 @@ declare const HASH_REGEX: RegExp;
  */
 declare const strToArr: (value: unknown, seperator?: string) => string[];
 
-export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DeferredOptions, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, type FiniteNumber, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type Integer, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type NegativeInteger, type NegativeNumber, type OptionalIf, type PositiveInteger, type PositiveNumber, type ReadOnlyAllowAddFn, ReadOnlyArrayHelper, type ReadOnlyConfig, type SearchOptions, type Slice, type SliceMapOptions, type SliceMapTransform, type SortOptions, type ThrottleOptions, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNegativeInteger, isNegativeNumber, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSubjectLike, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchObjOrProp, noop, noopAsync, objClean, objCopy, objCreate, objHasKeys, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, strToArr, throttled, toDatetimeLocal };
+export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DebounceOptions, type DeferredOptions, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, type FiniteNumber, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type Integer, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type NegativeInteger, type NegativeNumber, type OptionalIf, type PositiveInteger, type PositiveNumber, type ReadOnlyAllowAddFn, ReadOnlyArrayHelper, type ReadOnlyConfig, type SearchOptions, type Slice, type SliceMapOptions, type SliceMapTransform, type SortOptions, type ThrottleOptions, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNegativeInteger, isNegativeNumber, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSubjectLike, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchObjOrProp, noop, noopAsync, objClean, objCopy, objCreate, objHasKeys, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, strToArr, throttle, throttled, toDatetimeLocal };

package/dist/index.js

@@ -206,74 +206,6 @@ var fallbackIfFails = (target, args, fallback) => {
 };
 var fallbackIfFails_default = fallbackIfFails;
 
-// src/deferred.ts
-var deferred = (callback, delay = 50, config = {}) => {
-  const {
-    leading = deferred.defaults.leading,
-    onError = deferred.defaults.onError,
-    thisArg
-  } = config;
-  let { tid } = config;
-  if (thisArg !== void 0) callback = callback.bind(thisArg);
-  const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
-  let firstArgs = null;
-  const leadingGlobal = leading === "global";
-  return (...args) => {
-    clearTimeout(tid);
-    tid = setTimeout(() => {
-      firstArgs !== args && _callback(...args);
-      firstArgs = leadingGlobal ? true : null;
-    }, delay);
-    if (!leading || firstArgs) return;
-    firstArgs = args;
-    _callback(...args);
-  };
-};
-deferred.defaults = {
-  /**
-   * Set the default value of argument `leading` for the `deferred` function.
-   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-   */
-  leading: false,
-  /**
-   * Set the default value of argument `onError` for the `deferred` function.
-   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-   */
-  onError: void 0
-};
-var deferred_default = deferred;
-
-// src/debounce.ts
-var debounce = deferred_default;
-
-// src/throttled.ts
-var throttled = (callback, delay = 50, config = {}) => {
-  const { defaults: d } = throttled;
-  const { onError = d.onError, trailing = d.trailing, thisArg } = config;
-  let { tid } = config;
-  if (thisArg !== void 0) callback = callback.bind(thisArg);
-  const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
-  let trailArgs = null;
-  return (...args) => {
-    if (tid) {
-      trailArgs = args;
-      return;
-    }
-    tid = setTimeout(() => {
-      tid = void 0;
-      if (!trailing) return;
-      const cbArgs = trailArgs;
-      trailArgs = null;
-      cbArgs && cbArgs !== args && _callback(...cbArgs);
-    }, delay);
-    _callback(...args);
-  };
-};
-throttled.defaults = {
-  onError: void 0,
-  trailing: false
-};
-
 // src/toDatetimeLocal.ts
 var toDatetimeLocal = (dateStr) => {
   const date = new Date(dateStr);
@@ -538,6 +470,79 @@ function arrToMap(arr, key, flatDepth = 0) {
 // src/arr/arrUnique.ts
 var arrUnique = (arr, flatDepth = 0) => !isArr(arr) ? [] : Array.from(new Set(arr.flat(flatDepth)));
 
+// src/deferred/debounce.ts
+var debounce = (callback, delay = 50, config = {}) => {
+  const {
+    leading = debounce.defaults.leading,
+    onError = debounce.defaults.onError,
+    thisArg
+  } = config;
+  let { tid } = config;
+  if (thisArg !== void 0) callback = callback.bind(thisArg);
+  const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
+  let firstArgs = null;
+  const leadingGlobal = leading === "global";
+  return (...args) => {
+    clearTimeout(tid);
+    tid = setTimeout(() => {
+      firstArgs !== args && _callback(...args);
+      firstArgs = leadingGlobal ? true : null;
+    }, delay);
+    if (!leading || firstArgs) return;
+    firstArgs = args;
+    _callback(...args);
+  };
+};
+debounce.defaults = {
+  /**
+   * Set the default value of argument `leading` for the `deferred` function.
+   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+   */
+  leading: false,
+  /**
+   * Set the default value of argument `onError` for the `deferred` function.
+   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+   */
+  onError: void 0
+};
+var debounce_default = debounce;
+
+// src/deferred/throttle.ts
+var throttle = (callback, delay = 50, config = {}) => {
+  const { defaults: d } = throttle;
+  const { onError = d.onError, trailing = d.trailing, thisArg } = config;
+  let { tid } = config;
+  const handleCallback = (...args) => fallbackIfFails_default(
+    thisArg !== void 0 ? callback.bind(thisArg) : callback,
+    args,
+    !isFn(onError) ? void 0 : (err) => fallbackIfFails_default(onError, [err], void 0)
+  );
+  let trailArgs = null;
+  return (...args) => {
+    if (tid) {
+      trailArgs = args;
+      return;
+    }
+    tid = setTimeout(() => {
+      tid = void 0;
+      if (!trailing) return;
+      const cbArgs = trailArgs;
+      trailArgs = null;
+      cbArgs && cbArgs !== args && handleCallback(...cbArgs);
+    }, delay);
+    handleCallback(...args);
+  };
+};
+throttle.defaults = {
+  onError: void 0,
+  trailing: false
+};
+var throttled = throttle;
+var throttle_default = throttle;
+
+// src/deferred/deferred.ts
+var deferred = (callback, delay = 50, config = {}) => config.throttle ? throttle_default(callback, delay, config) : debounce_default(callback, delay, config);
+
 // src/iterable/filter.ts
 var filter = (data, predicate, limit, asArray, result) => {
   var _a;
@@ -682,7 +687,6 @@ function matchObjOrProp({
   let valueStr = String(value);
   if (!valueStr.trim()) return -1;
   if (isRegExp(keyword)) return (_b = (_a = valueStr.match(keyword)) == null ? void 0 : _a.index) != null ? _b : -1;
-  if (matchExact) return -1;
   if (ignoreCase) valueStr = valueStr.toLowerCase();
   return valueStr.indexOf(String(keyword));
 }
@@ -988,6 +992,7 @@ export {
   sliceMap,
   sort,
   strToArr,
+  throttle,
   throttled,
   toDatetimeLocal
 };

package/package.json

@@ -42,5 +42,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.1.5"
+	"version": "1.1.6"
 }