@usefy/use-debounce-callback 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,101 @@
+/**
+ * Options for useDebounceCallback hook
+ */
+interface UseDebounceCallbackOptions {
+    /**
+     * Maximum time the debounced function can be delayed
+     * @default undefined (no maximum)
+     */
+    maxWait?: number;
+    /**
+     * Whether to invoke on the leading edge
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * Whether to invoke on the trailing edge
+     * @default true
+     */
+    trailing?: boolean;
+}
+/**
+ * Debounced function interface with control methods
+ */
+interface DebouncedFunction<T extends (...args: any[]) => any> {
+    /**
+     * Call the debounced function
+     */
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Cancel any pending invocation
+     */
+    cancel: () => void;
+    /**
+     * Immediately invoke any pending invocation
+     */
+    flush: () => ReturnType<T> | undefined;
+    /**
+     * Check if there is a pending invocation
+     */
+    pending: () => boolean;
+}
+/**
+ * Creates a debounced version of the provided callback function.
+ * The debounced function delays invoking the callback until after `delay` milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @template T - The type of the callback function
+ * @param callback - The function to debounce
+ * @param delay - The delay in milliseconds (default: 500ms)
+ * @param options - Additional options for controlling debounce behavior
+ * @returns A debounced version of the callback with cancel, flush, and pending methods
+ *
+ * @example
+ * ```tsx
+ * function SearchComponent() {
+ *   const [results, setResults] = useState([]);
+ *
+ *   const debouncedSearch = useDebounceCallback(
+ *     async (query: string) => {
+ *       const data = await searchAPI(query);
+ *       setResults(data);
+ *     },
+ *     500
+ *   );
+ *
+ *   return (
+ *     <input
+ *       type="text"
+ *       onChange={(e) => debouncedSearch(e.target.value)}
+ *       placeholder="Search..."
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With leading edge invocation
+ * const debouncedFn = useDebounceCallback(callback, 300, { leading: true });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With maximum wait time
+ * const debouncedFn = useDebounceCallback(callback, 500, { maxWait: 2000 });
+ *
+ * // Cancel pending invocation
+ * debouncedFn.cancel();
+ *
+ * // Immediately invoke pending invocation
+ * debouncedFn.flush();
+ *
+ * // Check if there's a pending invocation
+ * if (debouncedFn.pending()) {
+ *   console.log('There is a pending call');
+ * }
+ * ```
+ */
+declare function useDebounceCallback<T extends (...args: any[]) => any>(callback: T, delay?: number, options?: UseDebounceCallbackOptions): DebouncedFunction<T>;
+
+export { type DebouncedFunction, type UseDebounceCallbackOptions, useDebounceCallback };

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Options for useDebounceCallback hook
+ */
+interface UseDebounceCallbackOptions {
+    /**
+     * Maximum time the debounced function can be delayed
+     * @default undefined (no maximum)
+     */
+    maxWait?: number;
+    /**
+     * Whether to invoke on the leading edge
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * Whether to invoke on the trailing edge
+     * @default true
+     */
+    trailing?: boolean;
+}
+/**
+ * Debounced function interface with control methods
+ */
+interface DebouncedFunction<T extends (...args: any[]) => any> {
+    /**
+     * Call the debounced function
+     */
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Cancel any pending invocation
+     */
+    cancel: () => void;
+    /**
+     * Immediately invoke any pending invocation
+     */
+    flush: () => ReturnType<T> | undefined;
+    /**
+     * Check if there is a pending invocation
+     */
+    pending: () => boolean;
+}
+/**
+ * Creates a debounced version of the provided callback function.
+ * The debounced function delays invoking the callback until after `delay` milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @template T - The type of the callback function
+ * @param callback - The function to debounce
+ * @param delay - The delay in milliseconds (default: 500ms)
+ * @param options - Additional options for controlling debounce behavior
+ * @returns A debounced version of the callback with cancel, flush, and pending methods
+ *
+ * @example
+ * ```tsx
+ * function SearchComponent() {
+ *   const [results, setResults] = useState([]);
+ *
+ *   const debouncedSearch = useDebounceCallback(
+ *     async (query: string) => {
+ *       const data = await searchAPI(query);
+ *       setResults(data);
+ *     },
+ *     500
+ *   );
+ *
+ *   return (
+ *     <input
+ *       type="text"
+ *       onChange={(e) => debouncedSearch(e.target.value)}
+ *       placeholder="Search..."
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With leading edge invocation
+ * const debouncedFn = useDebounceCallback(callback, 300, { leading: true });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With maximum wait time
+ * const debouncedFn = useDebounceCallback(callback, 500, { maxWait: 2000 });
+ *
+ * // Cancel pending invocation
+ * debouncedFn.cancel();
+ *
+ * // Immediately invoke pending invocation
+ * debouncedFn.flush();
+ *
+ * // Check if there's a pending invocation
+ * if (debouncedFn.pending()) {
+ *   console.log('There is a pending call');
+ * }
+ * ```
+ */
+declare function useDebounceCallback<T extends (...args: any[]) => any>(callback: T, delay?: number, options?: UseDebounceCallbackOptions): DebouncedFunction<T>;
+
+export { type DebouncedFunction, type UseDebounceCallbackOptions, useDebounceCallback };

package/dist/index.js

@@ -0,0 +1,187 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  useDebounceCallback: () => useDebounceCallback
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/useDebounceCallback.ts
+var import_react = require("react");
+function useDebounceCallback(callback, delay = 500, options = {}) {
+  const wait = delay || 0;
+  const leading = options.leading ?? false;
+  const trailing = options.trailing !== void 0 ? options.trailing : true;
+  const maxing = "maxWait" in options;
+  const maxWait = maxing ? Math.max(options.maxWait || 0, wait) : void 0;
+  const callbackRef = (0, import_react.useRef)(callback);
+  const timerIdRef = (0, import_react.useRef)(
+    void 0
+  );
+  const lastCallTimeRef = (0, import_react.useRef)(void 0);
+  const lastInvokeTimeRef = (0, import_react.useRef)(0);
+  const lastArgsRef = (0, import_react.useRef)(void 0);
+  const resultRef = (0, import_react.useRef)(void 0);
+  const waitRef = (0, import_react.useRef)(wait);
+  const leadingRef = (0, import_react.useRef)(leading);
+  const trailingRef = (0, import_react.useRef)(trailing);
+  const maxingRef = (0, import_react.useRef)(maxing);
+  const maxWaitRef = (0, import_react.useRef)(maxWait);
+  callbackRef.current = callback;
+  waitRef.current = wait;
+  leadingRef.current = leading;
+  trailingRef.current = trailing;
+  maxingRef.current = maxing;
+  maxWaitRef.current = maxWait;
+  const now = (0, import_react.useCallback)(() => Date.now(), []);
+  const shouldInvoke = (0, import_react.useCallback)((time) => {
+    const lastCallTime = lastCallTimeRef.current;
+    if (lastCallTime === void 0) {
+      return true;
+    }
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;
+    return timeSinceLastCall >= waitRef.current || timeSinceLastCall < 0 || // System time went backwards
+    maxingRef.current && timeSinceLastInvoke >= maxWaitRef.current;
+  }, []);
+  const invokeFunc = (0, import_react.useCallback)((time) => {
+    const args = lastArgsRef.current;
+    lastArgsRef.current = void 0;
+    lastInvokeTimeRef.current = time;
+    if (args !== void 0) {
+      resultRef.current = callbackRef.current(...args);
+    }
+    return resultRef.current;
+  }, []);
+  const remainingWait = (0, import_react.useCallback)((time) => {
+    const lastCallTime = lastCallTimeRef.current;
+    if (lastCallTime === void 0) {
+      return waitRef.current;
+    }
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;
+    const timeWaiting = waitRef.current - timeSinceLastCall;
+    return maxingRef.current ? Math.min(
+      timeWaiting,
+      maxWaitRef.current - timeSinceLastInvoke
+    ) : timeWaiting;
+  }, []);
+  const timerExpiredRef = (0, import_react.useRef)(() => {
+  });
+  const trailingEdge = (0, import_react.useCallback)(
+    (time) => {
+      timerIdRef.current = void 0;
+      if (trailingRef.current && lastArgsRef.current !== void 0) {
+        return invokeFunc(time);
+      }
+      lastArgsRef.current = void 0;
+      return resultRef.current;
+    },
+    [invokeFunc]
+  );
+  const timerExpired = (0, import_react.useCallback)(() => {
+    const time = now();
+    if (shouldInvoke(time)) {
+      trailingEdge(time);
+    } else {
+      timerIdRef.current = setTimeout(
+        timerExpiredRef.current,
+        remainingWait(time)
+      );
+    }
+  }, [now, shouldInvoke, trailingEdge, remainingWait]);
+  timerExpiredRef.current = timerExpired;
+  const leadingEdge = (0, import_react.useCallback)(
+    (time) => {
+      lastInvokeTimeRef.current = time;
+      timerIdRef.current = setTimeout(timerExpiredRef.current, waitRef.current);
+      return leadingRef.current ? invokeFunc(time) : resultRef.current;
+    },
+    [invokeFunc]
+  );
+  const cancel = (0, import_react.useCallback)(() => {
+    if (timerIdRef.current !== void 0) {
+      clearTimeout(timerIdRef.current);
+    }
+    lastInvokeTimeRef.current = 0;
+    lastArgsRef.current = void 0;
+    lastCallTimeRef.current = void 0;
+    timerIdRef.current = void 0;
+  }, []);
+  const flush = (0, import_react.useCallback)(() => {
+    if (timerIdRef.current === void 0) {
+      return resultRef.current;
+    }
+    return trailingEdge(now());
+  }, [now, trailingEdge]);
+  const pending = (0, import_react.useCallback)(() => {
+    return timerIdRef.current !== void 0;
+  }, []);
+  const debounced = (0, import_react.useCallback)(
+    (...args) => {
+      const time = now();
+      const isInvoking = shouldInvoke(time);
+      lastArgsRef.current = args;
+      lastCallTimeRef.current = time;
+      if (isInvoking) {
+        if (timerIdRef.current === void 0) {
+          return leadingEdge(time);
+        }
+        if (maxingRef.current) {
+          clearTimeout(timerIdRef.current);
+          timerIdRef.current = setTimeout(
+            timerExpiredRef.current,
+            waitRef.current
+          );
+          return invokeFunc(time);
+        }
+      }
+      if (timerIdRef.current === void 0) {
+        timerIdRef.current = setTimeout(
+          timerExpiredRef.current,
+          waitRef.current
+        );
+      }
+      return resultRef.current;
+    },
+    [now, shouldInvoke, leadingEdge, invokeFunc]
+  );
+  (0, import_react.useEffect)(() => {
+    return () => {
+      if (timerIdRef.current !== void 0) {
+        clearTimeout(timerIdRef.current);
+      }
+    };
+  }, []);
+  const debouncedWithMethods = (0, import_react.useMemo)(() => {
+    const fn = debounced;
+    fn.cancel = cancel;
+    fn.flush = flush;
+    fn.pending = pending;
+    return fn;
+  }, [debounced, cancel, flush, pending]);
+  return debouncedWithMethods;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDebounceCallback
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/useDebounceCallback.ts"],"sourcesContent":["export {\r\n  useDebounceCallback,\r\n  type UseDebounceCallbackOptions,\r\n  type DebouncedFunction,\r\n} from \"./useDebounceCallback\";\r\n","import { useCallback, useEffect, useMemo, useRef } from \"react\";\r\n\r\n/**\r\n * Options for useDebounceCallback hook\r\n */\r\nexport interface UseDebounceCallbackOptions {\r\n  /**\r\n   * Maximum time the debounced function can be delayed\r\n   * @default undefined (no maximum)\r\n   */\r\n  maxWait?: number;\r\n  /**\r\n   * Whether to invoke on the leading edge\r\n   * @default false\r\n   */\r\n  leading?: boolean;\r\n  /**\r\n   * Whether to invoke on the trailing edge\r\n   * @default true\r\n   */\r\n  trailing?: boolean;\r\n}\r\n\r\n/**\r\n * Debounced function interface with control methods\r\n */\r\nexport interface DebouncedFunction<T extends (...args: any[]) => any> {\r\n  /**\r\n   * Call the debounced function\r\n   */\r\n  (...args: Parameters<T>): ReturnType<T> | undefined;\r\n  /**\r\n   * Cancel any pending invocation\r\n   */\r\n  cancel: () => void;\r\n  /**\r\n   * Immediately invoke any pending invocation\r\n   */\r\n  flush: () => ReturnType<T> | undefined;\r\n  /**\r\n   * Check if there is a pending invocation\r\n   */\r\n  pending: () => boolean;\r\n}\r\n\r\n/**\r\n * Creates a debounced version of the provided callback function.\r\n * The debounced function delays invoking the callback until after `delay` milliseconds\r\n * have elapsed since the last time the debounced function was invoked.\r\n *\r\n * @template T - The type of the callback function\r\n * @param callback - The function to debounce\r\n * @param delay - The delay in milliseconds (default: 500ms)\r\n * @param options - Additional options for controlling debounce behavior\r\n * @returns A debounced version of the callback with cancel, flush, and pending methods\r\n *\r\n * @example\r\n * ```tsx\r\n * function SearchComponent() {\r\n *   const [results, setResults] = useState([]);\r\n *\r\n *   const debouncedSearch = useDebounceCallback(\r\n *     async (query: string) => {\r\n *       const data = await searchAPI(query);\r\n *       setResults(data);\r\n *     },\r\n *     500\r\n *   );\r\n *\r\n *   return (\r\n *     <input\r\n *       type=\"text\"\r\n *       onChange={(e) => debouncedSearch(e.target.value)}\r\n *       placeholder=\"Search...\"\r\n *     />\r\n *   );\r\n * }\r\n * ```\r\n *\r\n * @example\r\n * ```tsx\r\n * // With leading edge invocation\r\n * const debouncedFn = useDebounceCallback(callback, 300, { leading: true });\r\n * ```\r\n *\r\n * @example\r\n * ```tsx\r\n * // With maximum wait time\r\n * const debouncedFn = useDebounceCallback(callback, 500, { maxWait: 2000 });\r\n *\r\n * // Cancel pending invocation\r\n * debouncedFn.cancel();\r\n *\r\n * // Immediately invoke pending invocation\r\n * debouncedFn.flush();\r\n *\r\n * // Check if there's a pending invocation\r\n * if (debouncedFn.pending()) {\r\n *   console.log('There is a pending call');\r\n * }\r\n * ```\r\n */\r\nexport function useDebounceCallback<T extends (...args: any[]) => any>(\r\n  callback: T,\r\n  delay: number = 500,\r\n  options: UseDebounceCallbackOptions = {}\r\n): DebouncedFunction<T> {\r\n  // Parse options\r\n  const wait = delay || 0;\r\n  const leading = options.leading ?? false;\r\n  const trailing = options.trailing !== undefined ? options.trailing : true;\r\n  const maxing = \"maxWait\" in options;\r\n  const maxWait = maxing ? Math.max(options.maxWait || 0, wait) : undefined;\r\n\r\n  // Refs for mutable state\r\n  const callbackRef = useRef<T>(callback);\r\n  const timerIdRef = useRef<ReturnType<typeof setTimeout> | undefined>(\r\n    undefined\r\n  );\r\n  const lastCallTimeRef = useRef<number | undefined>(undefined);\r\n  const lastInvokeTimeRef = useRef<number>(0);\r\n  const lastArgsRef = useRef<Parameters<T> | undefined>(undefined);\r\n  const resultRef = useRef<ReturnType<T> | undefined>(undefined);\r\n\r\n  // Store options in refs\r\n  const waitRef = useRef(wait);\r\n  const leadingRef = useRef(leading);\r\n  const trailingRef = useRef(trailing);\r\n  const maxingRef = useRef(maxing);\r\n  const maxWaitRef = useRef(maxWait);\r\n\r\n  // Update callback ref on every render to always have the latest callback\r\n  callbackRef.current = callback;\r\n\r\n  // Update option refs when options change\r\n  waitRef.current = wait;\r\n  leadingRef.current = leading;\r\n  trailingRef.current = trailing;\r\n  maxingRef.current = maxing;\r\n  maxWaitRef.current = maxWait;\r\n\r\n  // Helper function to get current time\r\n  const now = useCallback(() => Date.now(), []);\r\n\r\n  // Helper function: shouldInvoke\r\n  const shouldInvoke = useCallback((time: number): boolean => {\r\n    const lastCallTime = lastCallTimeRef.current;\r\n    if (lastCallTime === undefined) {\r\n      return true; // First call\r\n    }\r\n\r\n    const timeSinceLastCall = time - lastCallTime;\r\n    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;\r\n\r\n    return (\r\n      timeSinceLastCall >= waitRef.current ||\r\n      timeSinceLastCall < 0 || // System time went backwards\r\n      (maxingRef.current &&\r\n        timeSinceLastInvoke >= (maxWaitRef.current as number))\r\n    );\r\n  }, []);\r\n\r\n  // Helper function: invokeFunc\r\n  const invokeFunc = useCallback((time: number): ReturnType<T> | undefined => {\r\n    const args = lastArgsRef.current;\r\n    lastArgsRef.current = undefined;\r\n    lastInvokeTimeRef.current = time;\r\n\r\n    if (args !== undefined) {\r\n      resultRef.current = callbackRef.current(...args);\r\n    }\r\n    return resultRef.current;\r\n  }, []);\r\n\r\n  // Helper function: remainingWait\r\n  const remainingWait = useCallback((time: number): number => {\r\n    const lastCallTime = lastCallTimeRef.current;\r\n    if (lastCallTime === undefined) {\r\n      return waitRef.current;\r\n    }\r\n\r\n    const timeSinceLastCall = time - lastCallTime;\r\n    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;\r\n    const timeWaiting = waitRef.current - timeSinceLastCall;\r\n\r\n    return maxingRef.current\r\n      ? Math.min(\r\n          timeWaiting,\r\n          (maxWaitRef.current as number) - timeSinceLastInvoke\r\n        )\r\n      : timeWaiting;\r\n  }, []);\r\n\r\n  // Forward declare timerExpired for mutual recursion\r\n  const timerExpiredRef = useRef<() => void>(() => {});\r\n\r\n  // Helper function: trailingEdge\r\n  const trailingEdge = useCallback(\r\n    (time: number): ReturnType<T> | undefined => {\r\n      timerIdRef.current = undefined;\r\n\r\n      // Only invoke if trailing is true and we have args (meaning the function was called)\r\n      if (trailingRef.current && lastArgsRef.current !== undefined) {\r\n        return invokeFunc(time);\r\n      }\r\n      lastArgsRef.current = undefined;\r\n      return resultRef.current;\r\n    },\r\n    [invokeFunc]\r\n  );\r\n\r\n  // Helper function: timerExpired\r\n  const timerExpired = useCallback((): void => {\r\n    const time = now();\r\n    if (shouldInvoke(time)) {\r\n      trailingEdge(time);\r\n    } else {\r\n      // Restart the timer\r\n      timerIdRef.current = setTimeout(\r\n        timerExpiredRef.current,\r\n        remainingWait(time)\r\n      );\r\n    }\r\n  }, [now, shouldInvoke, trailingEdge, remainingWait]);\r\n\r\n  // Update the ref after timerExpired is defined\r\n  timerExpiredRef.current = timerExpired;\r\n\r\n  // Helper function: leadingEdge\r\n  const leadingEdge = useCallback(\r\n    (time: number): ReturnType<T> | undefined => {\r\n      // Reset any `maxWait` timer\r\n      lastInvokeTimeRef.current = time;\r\n      // Start the timer for the trailing edge\r\n      timerIdRef.current = setTimeout(timerExpiredRef.current, waitRef.current);\r\n      // Invoke the leading edge\r\n      return leadingRef.current ? invokeFunc(time) : resultRef.current;\r\n    },\r\n    [invokeFunc]\r\n  );\r\n\r\n  // Cancel function\r\n  const cancel = useCallback((): void => {\r\n    if (timerIdRef.current !== undefined) {\r\n      clearTimeout(timerIdRef.current);\r\n    }\r\n    lastInvokeTimeRef.current = 0;\r\n    lastArgsRef.current = undefined;\r\n    lastCallTimeRef.current = undefined;\r\n    timerIdRef.current = undefined;\r\n  }, []);\r\n\r\n  // Flush function\r\n  const flush = useCallback((): ReturnType<T> | undefined => {\r\n    if (timerIdRef.current === undefined) {\r\n      return resultRef.current;\r\n    }\r\n    return trailingEdge(now());\r\n  }, [now, trailingEdge]);\r\n\r\n  // Pending function\r\n  const pending = useCallback((): boolean => {\r\n    return timerIdRef.current !== undefined;\r\n  }, []);\r\n\r\n  // Main debounced function\r\n  const debounced = useCallback(\r\n    (...args: Parameters<T>): ReturnType<T> | undefined => {\r\n      const time = now();\r\n      const isInvoking = shouldInvoke(time);\r\n\r\n      lastArgsRef.current = args;\r\n      lastCallTimeRef.current = time;\r\n\r\n      if (isInvoking) {\r\n        if (timerIdRef.current === undefined) {\r\n          return leadingEdge(time);\r\n        }\r\n        if (maxingRef.current) {\r\n          // Handle invocations in a tight loop\r\n          clearTimeout(timerIdRef.current);\r\n          timerIdRef.current = setTimeout(\r\n            timerExpiredRef.current,\r\n            waitRef.current\r\n          );\r\n          return invokeFunc(time);\r\n        }\r\n      }\r\n      if (timerIdRef.current === undefined) {\r\n        timerIdRef.current = setTimeout(\r\n          timerExpiredRef.current,\r\n          waitRef.current\r\n        );\r\n      }\r\n      return resultRef.current;\r\n    },\r\n    [now, shouldInvoke, leadingEdge, invokeFunc]\r\n  );\r\n\r\n  // Cleanup on unmount\r\n  useEffect(() => {\r\n    return () => {\r\n      if (timerIdRef.current !== undefined) {\r\n        clearTimeout(timerIdRef.current);\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  // Create the debounced function with attached methods\r\n  const debouncedWithMethods = useMemo(() => {\r\n    const fn = debounced as DebouncedFunction<T>;\r\n    fn.cancel = cancel;\r\n    fn.flush = flush;\r\n    fn.pending = pending;\r\n    return fn;\r\n  }, [debounced, cancel, flush, pending]);\r\n\r\n  return debouncedWithMethods;\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -0,0 +1,160 @@
+// src/useDebounceCallback.ts
+import { useCallback, useEffect, useMemo, useRef } from "react";
+function useDebounceCallback(callback, delay = 500, options = {}) {
+  const wait = delay || 0;
+  const leading = options.leading ?? false;
+  const trailing = options.trailing !== void 0 ? options.trailing : true;
+  const maxing = "maxWait" in options;
+  const maxWait = maxing ? Math.max(options.maxWait || 0, wait) : void 0;
+  const callbackRef = useRef(callback);
+  const timerIdRef = useRef(
+    void 0
+  );
+  const lastCallTimeRef = useRef(void 0);
+  const lastInvokeTimeRef = useRef(0);
+  const lastArgsRef = useRef(void 0);
+  const resultRef = useRef(void 0);
+  const waitRef = useRef(wait);
+  const leadingRef = useRef(leading);
+  const trailingRef = useRef(trailing);
+  const maxingRef = useRef(maxing);
+  const maxWaitRef = useRef(maxWait);
+  callbackRef.current = callback;
+  waitRef.current = wait;
+  leadingRef.current = leading;
+  trailingRef.current = trailing;
+  maxingRef.current = maxing;
+  maxWaitRef.current = maxWait;
+  const now = useCallback(() => Date.now(), []);
+  const shouldInvoke = useCallback((time) => {
+    const lastCallTime = lastCallTimeRef.current;
+    if (lastCallTime === void 0) {
+      return true;
+    }
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;
+    return timeSinceLastCall >= waitRef.current || timeSinceLastCall < 0 || // System time went backwards
+    maxingRef.current && timeSinceLastInvoke >= maxWaitRef.current;
+  }, []);
+  const invokeFunc = useCallback((time) => {
+    const args = lastArgsRef.current;
+    lastArgsRef.current = void 0;
+    lastInvokeTimeRef.current = time;
+    if (args !== void 0) {
+      resultRef.current = callbackRef.current(...args);
+    }
+    return resultRef.current;
+  }, []);
+  const remainingWait = useCallback((time) => {
+    const lastCallTime = lastCallTimeRef.current;
+    if (lastCallTime === void 0) {
+      return waitRef.current;
+    }
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;
+    const timeWaiting = waitRef.current - timeSinceLastCall;
+    return maxingRef.current ? Math.min(
+      timeWaiting,
+      maxWaitRef.current - timeSinceLastInvoke
+    ) : timeWaiting;
+  }, []);
+  const timerExpiredRef = useRef(() => {
+  });
+  const trailingEdge = useCallback(
+    (time) => {
+      timerIdRef.current = void 0;
+      if (trailingRef.current && lastArgsRef.current !== void 0) {
+        return invokeFunc(time);
+      }
+      lastArgsRef.current = void 0;
+      return resultRef.current;
+    },
+    [invokeFunc]
+  );
+  const timerExpired = useCallback(() => {
+    const time = now();
+    if (shouldInvoke(time)) {
+      trailingEdge(time);
+    } else {
+      timerIdRef.current = setTimeout(
+        timerExpiredRef.current,
+        remainingWait(time)
+      );
+    }
+  }, [now, shouldInvoke, trailingEdge, remainingWait]);
+  timerExpiredRef.current = timerExpired;
+  const leadingEdge = useCallback(
+    (time) => {
+      lastInvokeTimeRef.current = time;
+      timerIdRef.current = setTimeout(timerExpiredRef.current, waitRef.current);
+      return leadingRef.current ? invokeFunc(time) : resultRef.current;
+    },
+    [invokeFunc]
+  );
+  const cancel = useCallback(() => {
+    if (timerIdRef.current !== void 0) {
+      clearTimeout(timerIdRef.current);
+    }
+    lastInvokeTimeRef.current = 0;
+    lastArgsRef.current = void 0;
+    lastCallTimeRef.current = void 0;
+    timerIdRef.current = void 0;
+  }, []);
+  const flush = useCallback(() => {
+    if (timerIdRef.current === void 0) {
+      return resultRef.current;
+    }
+    return trailingEdge(now());
+  }, [now, trailingEdge]);
+  const pending = useCallback(() => {
+    return timerIdRef.current !== void 0;
+  }, []);
+  const debounced = useCallback(
+    (...args) => {
+      const time = now();
+      const isInvoking = shouldInvoke(time);
+      lastArgsRef.current = args;
+      lastCallTimeRef.current = time;
+      if (isInvoking) {
+        if (timerIdRef.current === void 0) {
+          return leadingEdge(time);
+        }
+        if (maxingRef.current) {
+          clearTimeout(timerIdRef.current);
+          timerIdRef.current = setTimeout(
+            timerExpiredRef.current,
+            waitRef.current
+          );
+          return invokeFunc(time);
+        }
+      }
+      if (timerIdRef.current === void 0) {
+        timerIdRef.current = setTimeout(
+          timerExpiredRef.current,
+          waitRef.current
+        );
+      }
+      return resultRef.current;
+    },
+    [now, shouldInvoke, leadingEdge, invokeFunc]
+  );
+  useEffect(() => {
+    return () => {
+      if (timerIdRef.current !== void 0) {
+        clearTimeout(timerIdRef.current);
+      }
+    };
+  }, []);
+  const debouncedWithMethods = useMemo(() => {
+    const fn = debounced;
+    fn.cancel = cancel;
+    fn.flush = flush;
+    fn.pending = pending;
+    return fn;
+  }, [debounced, cancel, flush, pending]);
+  return debouncedWithMethods;
+}
+export {
+  useDebounceCallback
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useDebounceCallback.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef } from \"react\";\r\n\r\n/**\r\n * Options for useDebounceCallback hook\r\n */\r\nexport interface UseDebounceCallbackOptions {\r\n  /**\r\n   * Maximum time the debounced function can be delayed\r\n   * @default undefined (no maximum)\r\n   */\r\n  maxWait?: number;\r\n  /**\r\n   * Whether to invoke on the leading edge\r\n   * @default false\r\n   */\r\n  leading?: boolean;\r\n  /**\r\n   * Whether to invoke on the trailing edge\r\n   * @default true\r\n   */\r\n  trailing?: boolean;\r\n}\r\n\r\n/**\r\n * Debounced function interface with control methods\r\n */\r\nexport interface DebouncedFunction<T extends (...args: any[]) => any> {\r\n  /**\r\n   * Call the debounced function\r\n   */\r\n  (...args: Parameters<T>): ReturnType<T> | undefined;\r\n  /**\r\n   * Cancel any pending invocation\r\n   */\r\n  cancel: () => void;\r\n  /**\r\n   * Immediately invoke any pending invocation\r\n   */\r\n  flush: () => ReturnType<T> | undefined;\r\n  /**\r\n   * Check if there is a pending invocation\r\n   */\r\n  pending: () => boolean;\r\n}\r\n\r\n/**\r\n * Creates a debounced version of the provided callback function.\r\n * The debounced function delays invoking the callback until after `delay` milliseconds\r\n * have elapsed since the last time the debounced function was invoked.\r\n *\r\n * @template T - The type of the callback function\r\n * @param callback - The function to debounce\r\n * @param delay - The delay in milliseconds (default: 500ms)\r\n * @param options - Additional options for controlling debounce behavior\r\n * @returns A debounced version of the callback with cancel, flush, and pending methods\r\n *\r\n * @example\r\n * ```tsx\r\n * function SearchComponent() {\r\n *   const [results, setResults] = useState([]);\r\n *\r\n *   const debouncedSearch = useDebounceCallback(\r\n *     async (query: string) => {\r\n *       const data = await searchAPI(query);\r\n *       setResults(data);\r\n *     },\r\n *     500\r\n *   );\r\n *\r\n *   return (\r\n *     <input\r\n *       type=\"text\"\r\n *       onChange={(e) => debouncedSearch(e.target.value)}\r\n *       placeholder=\"Search...\"\r\n *     />\r\n *   );\r\n * }\r\n * ```\r\n *\r\n * @example\r\n * ```tsx\r\n * // With leading edge invocation\r\n * const debouncedFn = useDebounceCallback(callback, 300, { leading: true });\r\n * ```\r\n *\r\n * @example\r\n * ```tsx\r\n * // With maximum wait time\r\n * const debouncedFn = useDebounceCallback(callback, 500, { maxWait: 2000 });\r\n *\r\n * // Cancel pending invocation\r\n * debouncedFn.cancel();\r\n *\r\n * // Immediately invoke pending invocation\r\n * debouncedFn.flush();\r\n *\r\n * // Check if there's a pending invocation\r\n * if (debouncedFn.pending()) {\r\n *   console.log('There is a pending call');\r\n * }\r\n * ```\r\n */\r\nexport function useDebounceCallback<T extends (...args: any[]) => any>(\r\n  callback: T,\r\n  delay: number = 500,\r\n  options: UseDebounceCallbackOptions = {}\r\n): DebouncedFunction<T> {\r\n  // Parse options\r\n  const wait = delay || 0;\r\n  const leading = options.leading ?? false;\r\n  const trailing = options.trailing !== undefined ? options.trailing : true;\r\n  const maxing = \"maxWait\" in options;\r\n  const maxWait = maxing ? Math.max(options.maxWait || 0, wait) : undefined;\r\n\r\n  // Refs for mutable state\r\n  const callbackRef = useRef<T>(callback);\r\n  const timerIdRef = useRef<ReturnType<typeof setTimeout> | undefined>(\r\n    undefined\r\n  );\r\n  const lastCallTimeRef = useRef<number | undefined>(undefined);\r\n  const lastInvokeTimeRef = useRef<number>(0);\r\n  const lastArgsRef = useRef<Parameters<T> | undefined>(undefined);\r\n  const resultRef = useRef<ReturnType<T> | undefined>(undefined);\r\n\r\n  // Store options in refs\r\n  const waitRef = useRef(wait);\r\n  const leadingRef = useRef(leading);\r\n  const trailingRef = useRef(trailing);\r\n  const maxingRef = useRef(maxing);\r\n  const maxWaitRef = useRef(maxWait);\r\n\r\n  // Update callback ref on every render to always have the latest callback\r\n  callbackRef.current = callback;\r\n\r\n  // Update option refs when options change\r\n  waitRef.current = wait;\r\n  leadingRef.current = leading;\r\n  trailingRef.current = trailing;\r\n  maxingRef.current = maxing;\r\n  maxWaitRef.current = maxWait;\r\n\r\n  // Helper function to get current time\r\n  const now = useCallback(() => Date.now(), []);\r\n\r\n  // Helper function: shouldInvoke\r\n  const shouldInvoke = useCallback((time: number): boolean => {\r\n    const lastCallTime = lastCallTimeRef.current;\r\n    if (lastCallTime === undefined) {\r\n      return true; // First call\r\n    }\r\n\r\n    const timeSinceLastCall = time - lastCallTime;\r\n    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;\r\n\r\n    return (\r\n      timeSinceLastCall >= waitRef.current ||\r\n      timeSinceLastCall < 0 || // System time went backwards\r\n      (maxingRef.current &&\r\n        timeSinceLastInvoke >= (maxWaitRef.current as number))\r\n    );\r\n  }, []);\r\n\r\n  // Helper function: invokeFunc\r\n  const invokeFunc = useCallback((time: number): ReturnType<T> | undefined => {\r\n    const args = lastArgsRef.current;\r\n    lastArgsRef.current = undefined;\r\n    lastInvokeTimeRef.current = time;\r\n\r\n    if (args !== undefined) {\r\n      resultRef.current = callbackRef.current(...args);\r\n    }\r\n    return resultRef.current;\r\n  }, []);\r\n\r\n  // Helper function: remainingWait\r\n  const remainingWait = useCallback((time: number): number => {\r\n    const lastCallTime = lastCallTimeRef.current;\r\n    if (lastCallTime === undefined) {\r\n      return waitRef.current;\r\n    }\r\n\r\n    const timeSinceLastCall = time - lastCallTime;\r\n    const timeSinceLastInvoke = time - lastInvokeTimeRef.current;\r\n    const timeWaiting = waitRef.current - timeSinceLastCall;\r\n\r\n    return maxingRef.current\r\n      ? Math.min(\r\n          timeWaiting,\r\n          (maxWaitRef.current as number) - timeSinceLastInvoke\r\n        )\r\n      : timeWaiting;\r\n  }, []);\r\n\r\n  // Forward declare timerExpired for mutual recursion\r\n  const timerExpiredRef = useRef<() => void>(() => {});\r\n\r\n  // Helper function: trailingEdge\r\n  const trailingEdge = useCallback(\r\n    (time: number): ReturnType<T> | undefined => {\r\n      timerIdRef.current = undefined;\r\n\r\n      // Only invoke if trailing is true and we have args (meaning the function was called)\r\n      if (trailingRef.current && lastArgsRef.current !== undefined) {\r\n        return invokeFunc(time);\r\n      }\r\n      lastArgsRef.current = undefined;\r\n      return resultRef.current;\r\n    },\r\n    [invokeFunc]\r\n  );\r\n\r\n  // Helper function: timerExpired\r\n  const timerExpired = useCallback((): void => {\r\n    const time = now();\r\n    if (shouldInvoke(time)) {\r\n      trailingEdge(time);\r\n    } else {\r\n      // Restart the timer\r\n      timerIdRef.current = setTimeout(\r\n        timerExpiredRef.current,\r\n        remainingWait(time)\r\n      );\r\n    }\r\n  }, [now, shouldInvoke, trailingEdge, remainingWait]);\r\n\r\n  // Update the ref after timerExpired is defined\r\n  timerExpiredRef.current = timerExpired;\r\n\r\n  // Helper function: leadingEdge\r\n  const leadingEdge = useCallback(\r\n    (time: number): ReturnType<T> | undefined => {\r\n      // Reset any `maxWait` timer\r\n      lastInvokeTimeRef.current = time;\r\n      // Start the timer for the trailing edge\r\n      timerIdRef.current = setTimeout(timerExpiredRef.current, waitRef.current);\r\n      // Invoke the leading edge\r\n      return leadingRef.current ? invokeFunc(time) : resultRef.current;\r\n    },\r\n    [invokeFunc]\r\n  );\r\n\r\n  // Cancel function\r\n  const cancel = useCallback((): void => {\r\n    if (timerIdRef.current !== undefined) {\r\n      clearTimeout(timerIdRef.current);\r\n    }\r\n    lastInvokeTimeRef.current = 0;\r\n    lastArgsRef.current = undefined;\r\n    lastCallTimeRef.current = undefined;\r\n    timerIdRef.current = undefined;\r\n  }, []);\r\n\r\n  // Flush function\r\n  const flush = useCallback((): ReturnType<T> | undefined => {\r\n    if (timerIdRef.current === undefined) {\r\n      return resultRef.current;\r\n    }\r\n    return trailingEdge(now());\r\n  }, [now, trailingEdge]);\r\n\r\n  // Pending function\r\n  const pending = useCallback((): boolean => {\r\n    return timerIdRef.current !== undefined;\r\n  }, []);\r\n\r\n  // Main debounced function\r\n  const debounced = useCallback(\r\n    (...args: Parameters<T>): ReturnType<T> | undefined => {\r\n      const time = now();\r\n      const isInvoking = shouldInvoke(time);\r\n\r\n      lastArgsRef.current = args;\r\n      lastCallTimeRef.current = time;\r\n\r\n      if (isInvoking) {\r\n        if (timerIdRef.current === undefined) {\r\n          return leadingEdge(time);\r\n        }\r\n        if (maxingRef.current) {\r\n          // Handle invocations in a tight loop\r\n          clearTimeout(timerIdRef.current);\r\n          timerIdRef.current = setTimeout(\r\n            timerExpiredRef.current,\r\n            waitRef.current\r\n          );\r\n          return invokeFunc(time);\r\n        }\r\n      }\r\n      if (timerIdRef.current === undefined) {\r\n        timerIdRef.current = setTimeout(\r\n          timerExpiredRef.current,\r\n          waitRef.current\r\n        );\r\n      }\r\n      return resultRef.current;\r\n    },\r\n    [now, shouldInvoke, leadingEdge, invokeFunc]\r\n  );\r\n\r\n  // Cleanup on unmount\r\n  useEffect(() => {\r\n    return () => {\r\n      if (timerIdRef.current !== undefined) {\r\n        clearTimeout(timerIdRef.current);\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  // Create the debounced function with attached methods\r\n  const debouncedWithMethods = useMemo(() => {\r\n    const fn = debounced as DebouncedFunction<T>;\r\n    fn.cancel = cancel;\r\n    fn.flush = flush;\r\n    fn.pending = pending;\r\n    return fn;\r\n  }, [debounced, cancel, flush, pending]);\r\n\r\n  return debouncedWithMethods;\r\n}\r\n"],"mappings":";AAAA,SAAS,aAAa,WAAW,SAAS,cAAc;AAsGjD,SAAS,oBACd,UACA,QAAgB,KAChB,UAAsC,CAAC,GACjB;AAEtB,QAAM,OAAO,SAAS;AACtB,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,WAAW,QAAQ,aAAa,SAAY,QAAQ,WAAW;AACrE,QAAM,SAAS,aAAa;AAC5B,QAAM,UAAU,SAAS,KAAK,IAAI,QAAQ,WAAW,GAAG,IAAI,IAAI;AAGhE,QAAM,cAAc,OAAU,QAAQ;AACtC,QAAM,aAAa;AAAA,IACjB;AAAA,EACF;AACA,QAAM,kBAAkB,OAA2B,MAAS;AAC5D,QAAM,oBAAoB,OAAe,CAAC;AAC1C,QAAM,cAAc,OAAkC,MAAS;AAC/D,QAAM,YAAY,OAAkC,MAAS;AAG7D,QAAM,UAAU,OAAO,IAAI;AAC3B,QAAM,aAAa,OAAO,OAAO;AACjC,QAAM,cAAc,OAAO,QAAQ;AACnC,QAAM,YAAY,OAAO,MAAM;AAC/B,QAAM,aAAa,OAAO,OAAO;AAGjC,cAAY,UAAU;AAGtB,UAAQ,UAAU;AAClB,aAAW,UAAU;AACrB,cAAY,UAAU;AACtB,YAAU,UAAU;AACpB,aAAW,UAAU;AAGrB,QAAM,MAAM,YAAY,MAAM,KAAK,IAAI,GAAG,CAAC,CAAC;AAG5C,QAAM,eAAe,YAAY,CAAC,SAA0B;AAC1D,UAAM,eAAe,gBAAgB;AACrC,QAAI,iBAAiB,QAAW;AAC9B,aAAO;AAAA,IACT;AAEA,UAAM,oBAAoB,OAAO;AACjC,UAAM,sBAAsB,OAAO,kBAAkB;AAErD,WACE,qBAAqB,QAAQ,WAC7B,oBAAoB;AAAA,IACnB,UAAU,WACT,uBAAwB,WAAW;AAAA,EAEzC,GAAG,CAAC,CAAC;AAGL,QAAM,aAAa,YAAY,CAAC,SAA4C;AAC1E,UAAM,OAAO,YAAY;AACzB,gBAAY,UAAU;AACtB,sBAAkB,UAAU;AAE5B,QAAI,SAAS,QAAW;AACtB,gBAAU,UAAU,YAAY,QAAQ,GAAG,IAAI;AAAA,IACjD;AACA,WAAO,UAAU;AAAA,EACnB,GAAG,CAAC,CAAC;AAGL,QAAM,gBAAgB,YAAY,CAAC,SAAyB;AAC1D,UAAM,eAAe,gBAAgB;AACrC,QAAI,iBAAiB,QAAW;AAC9B,aAAO,QAAQ;AAAA,IACjB;AAEA,UAAM,oBAAoB,OAAO;AACjC,UAAM,sBAAsB,OAAO,kBAAkB;AACrD,UAAM,cAAc,QAAQ,UAAU;AAEtC,WAAO,UAAU,UACb,KAAK;AAAA,MACH;AAAA,MACC,WAAW,UAAqB;AAAA,IACnC,IACA;AAAA,EACN,GAAG,CAAC,CAAC;AAGL,QAAM,kBAAkB,OAAmB,MAAM;AAAA,EAAC,CAAC;AAGnD,QAAM,eAAe;AAAA,IACnB,CAAC,SAA4C;AAC3C,iBAAW,UAAU;AAGrB,UAAI,YAAY,WAAW,YAAY,YAAY,QAAW;AAC5D,eAAO,WAAW,IAAI;AAAA,MACxB;AACA,kBAAY,UAAU;AACtB,aAAO,UAAU;AAAA,IACnB;AAAA,IACA,CAAC,UAAU;AAAA,EACb;AAGA,QAAM,eAAe,YAAY,MAAY;AAC3C,UAAM,OAAO,IAAI;AACjB,QAAI,aAAa,IAAI,GAAG;AACtB,mBAAa,IAAI;AAAA,IACnB,OAAO;AAEL,iBAAW,UAAU;AAAA,QACnB,gBAAgB;AAAA,QAChB,cAAc,IAAI;AAAA,MACpB;AAAA,IACF;AAAA,EACF,GAAG,CAAC,KAAK,cAAc,cAAc,aAAa,CAAC;AAGnD,kBAAgB,UAAU;AAG1B,QAAM,cAAc;AAAA,IAClB,CAAC,SAA4C;AAE3C,wBAAkB,UAAU;AAE5B,iBAAW,UAAU,WAAW,gBAAgB,SAAS,QAAQ,OAAO;AAExE,aAAO,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU;AAAA,IAC3D;AAAA,IACA,CAAC,UAAU;AAAA,EACb;AAGA,QAAM,SAAS,YAAY,MAAY;AACrC,QAAI,WAAW,YAAY,QAAW;AACpC,mBAAa,WAAW,OAAO;AAAA,IACjC;AACA,sBAAkB,UAAU;AAC5B,gBAAY,UAAU;AACtB,oBAAgB,UAAU;AAC1B,eAAW,UAAU;AAAA,EACvB,GAAG,CAAC,CAAC;AAGL,QAAM,QAAQ,YAAY,MAAiC;AACzD,QAAI,WAAW,YAAY,QAAW;AACpC,aAAO,UAAU;AAAA,IACnB;AACA,WAAO,aAAa,IAAI,CAAC;AAAA,EAC3B,GAAG,CAAC,KAAK,YAAY,CAAC;AAGtB,QAAM,UAAU,YAAY,MAAe;AACzC,WAAO,WAAW,YAAY;AAAA,EAChC,GAAG,CAAC,CAAC;AAGL,QAAM,YAAY;AAAA,IAChB,IAAI,SAAmD;AACrD,YAAM,OAAO,IAAI;AACjB,YAAM,aAAa,aAAa,IAAI;AAEpC,kBAAY,UAAU;AACtB,sBAAgB,UAAU;AAE1B,UAAI,YAAY;AACd,YAAI,WAAW,YAAY,QAAW;AACpC,iBAAO,YAAY,IAAI;AAAA,QACzB;AACA,YAAI,UAAU,SAAS;AAErB,uBAAa,WAAW,OAAO;AAC/B,qBAAW,UAAU;AAAA,YACnB,gBAAgB;AAAA,YAChB,QAAQ;AAAA,UACV;AACA,iBAAO,WAAW,IAAI;AAAA,QACxB;AAAA,MACF;AACA,UAAI,WAAW,YAAY,QAAW;AACpC,mBAAW,UAAU;AAAA,UACnB,gBAAgB;AAAA,UAChB,QAAQ;AAAA,QACV;AAAA,MACF;AACA,aAAO,UAAU;AAAA,IACnB;AAAA,IACA,CAAC,KAAK,cAAc,aAAa,UAAU;AAAA,EAC7C;AAGA,YAAU,MAAM;AACd,WAAO,MAAM;AACX,UAAI,WAAW,YAAY,QAAW;AACpC,qBAAa,WAAW,OAAO;AAAA,MACjC;AAAA,IACF;AAAA,EACF,GAAG,CAAC,CAAC;AAGL,QAAM,uBAAuB,QAAQ,MAAM;AACzC,UAAM,KAAK;AACX,OAAG,SAAS;AACZ,OAAG,QAAQ;AACX,OAAG,UAAU;AACb,WAAO;AAAA,EACT,GAAG,CAAC,WAAW,QAAQ,OAAO,OAAO,CAAC;AAEtC,SAAO;AACT;","names":[]}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@usefy/use-debounce-callback",
+  "version": "0.0.2",
+  "description": "A React hook for debouncing callback functions",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.1",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.0.0",
+    "jsdom": "^27.3.0",
+    "react": "^19.0.0",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geon0529/usefy.git",
+    "directory": "packages/use-debounce-callback"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "hooks",
+    "debounce",
+    "callback",
+    "throttle"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist"
+  }
+}