@ledgerhq/lumen-utils-shared 0.0.17 → 0.0.18

package/dist/index.d.ts

@@ -5,4 +5,6 @@ export * from './lib/cn';
 export * from './lib/isTextChildren';
 export * from './lib/useMergeRef';
 export * from './lib/getObjectPath';
+export * from './lib/throttle';
+export * from './lib/debounce';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,61 +1,61 @@
-import { jsx as h } from "react/jsx-runtime";
-import { createContext as x, useMemo as m, useContext as y } from "react";
-import { clsx as P } from "clsx";
-import { twMerge as S } from "tailwind-merge";
-function w(t) {
+import { jsx as W } from "react/jsx-runtime";
+import { createContext as k, useMemo as A, useContext as F } from "react";
+import { clsx as _ } from "clsx";
+import { twMerge as j } from "tailwind-merge";
+function q(t) {
   return t ? t.split(/[-_ ]+/).map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join("") : "";
 }
-const C = 48, A = 17, M = 2;
-function E(t) {
+const z = 48, N = 17, R = 2;
+function G(t) {
   const n = t.replace(/\D/g, "").length;
   return Math.max(
-    A,
-    C - n * M
+    N,
+    z - n * R
   );
 }
-function f(t, n = !0) {
+function D(t, n = !0) {
   if (!t) return "";
-  const i = t.includes("."), [o, r] = t.split("."), c = o.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
-  return i && n ? r ? `${c}.${r}` : `${c}.` : c;
+  const l = t.includes("."), [o, r] = t.split("."), c = o.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+  return l && n ? r ? `${c}.${r}` : `${c}.` : c;
 }
-function T(t, n = {}) {
+function H(t, n = {}) {
   const {
-    allowDecimals: i = !0,
+    allowDecimals: l = !0,
     thousandsSeparator: o = !0,
     maxIntegerLength: r = 9,
     maxDecimalLength: c = 9
-  } = n, a = t.replace(",", ".").replace(/[^\d.]/g, "");
-  let e = a;
-  if (e = e.replace(/^0+(?=\d)/, ""), !i)
-    return e = e.replace(/\D/g, ""), r > 0 && e.length > r && (e = e.slice(0, r)), o ? f(e) : e;
+  } = n, i = t.replace(",", ".").replace(/[^\d.]/g, "");
+  let e = i;
+  if (e = e.replace(/^0+(?=\d)/, ""), !l)
+    return e = e.replace(/\D/g, ""), r > 0 && e.length > r && (e = e.slice(0, r)), o ? D(e) : e;
   e === "." && (e = "0.");
-  const l = e.indexOf(".");
-  if (l !== -1) {
-    let s = e.slice(0, l), u = e.slice(l + 1).replace(/\./g, "");
-    r > 0 && s.length > r && (s = s.slice(0, r)), u = u.slice(0, c), s === "" && (s = "0");
-    const d = a.endsWith(".") || e.endsWith(".");
-    e = u.length > 0 ? `${s}.${u}` : d ? `${s}.` : s;
+  const f = e.indexOf(".");
+  if (f !== -1) {
+    let s = e.slice(0, f), a = e.slice(f + 1).replace(/\./g, "");
+    r > 0 && s.length > r && (s = s.slice(0, r)), a = a.slice(0, c), s === "" && (s = "0");
+    const g = i.endsWith(".") || e.endsWith(".");
+    e = a.length > 0 ? `${s}.${a}` : g ? `${s}.` : s;
   } else
     r > 0 && e.length > r && (e = e.slice(0, r));
-  return o ? f(e) : e;
+  return o ? D(e) : e;
 }
-function _(t, n) {
-  const i = x(n), o = ({ children: c, value: a }) => {
-    const e = m(
-      () => a,
-      Object.values(a ?? {})
+function J(t, n) {
+  const l = k(n), o = ({ children: c, value: i }) => {
+    const e = A(
+      () => i,
+      Object.values(i ?? {})
     );
-    return /* @__PURE__ */ h(i.Provider, { value: e, children: c });
+    return /* @__PURE__ */ W(l.Provider, { value: e, children: c });
   };
   o.displayName = t + "Provider";
   function r({
     consumerName: c,
-    contextRequired: a
+    contextRequired: i
   }) {
-    const e = y(i);
+    const e = F(l);
     if (e)
       return e;
-    if (a)
+    if (i)
       throw new Error(
         `${c} must be used within ${t}`
       );
@@ -63,53 +63,100 @@ function _(t, n) {
   }
   return [o, r];
 }
-function j(...t) {
-  return S(P(t));
+function K(...t) {
+  return j(_(t));
 }
-const p = (t) => typeof t == "string" || typeof t == "number", F = (t) => Array.isArray(t) ? t.every(p) : p(t);
-function g(t, n) {
+const I = (t) => typeof t == "string" || typeof t == "number", Q = (t) => Array.isArray(t) ? t.every(I) : I(t);
+function M(t, n) {
   if (typeof t == "function")
     return t(n);
   typeof t == "object" && t !== null && "current" in t && (t.current = n);
 }
-function $(...t) {
+function w(...t) {
   const n = /* @__PURE__ */ new Map();
-  return (i) => {
-    if (i === null) {
+  return (l) => {
+    if (l === null) {
       t.forEach((o) => {
         const r = n.get(o);
-        typeof r == "function" && r(), g(o, null);
+        typeof r == "function" && r(), M(o, null);
       }), n.clear();
       return;
     }
     t.forEach((o) => {
-      const r = g(o, i);
+      const r = M(o, l);
       typeof r == "function" && n.set(o, r);
     });
   };
 }
-function I(...t) {
-  return m(() => $(...t), t);
+function Y(...t) {
+  return A(() => w(...t), t);
 }
-const z = (t, n) => {
-  let i = t;
+const tt = (t, n) => {
+  let l = t;
   for (const o of n) {
-    if (i == null)
+    if (l == null)
       return;
-    i = i[o];
+    l = l[o];
   }
-  return i;
+  return l;
 };
+function V(t, n, l = {}) {
+  const { leading: o = !1, trailing: r = !0, maxWait: c } = l;
+  let i = null, e = null, f = null, s = 0, a = null, g = null, d;
+  const x = c !== void 0, S = x ? Math.max(c, n) : 0, T = (u) => {
+    s = u;
+    const m = a, h = g;
+    return a = null, g = null, d = t.apply(h, m), d;
+  }, E = (u) => {
+    const m = f ? u - f : 0;
+    return n - m;
+  }, v = (u) => {
+    const m = f ? u - f : n, h = u - s;
+    return f === null || m >= n || m < 0 || x && h >= S;
+  }, C = (u) => (i = null, r && a ? T(u) : (a = null, g = null, d)), p = () => {
+    const u = Date.now();
+    if (v(u)) {
+      C(u);
+      return;
+    }
+    i = setTimeout(p, E(u));
+  }, P = () => {
+    const u = Date.now();
+    e = null, a && (T(u), i !== null && (clearTimeout(i), i = setTimeout(p, n)));
+  }, b = (u) => (s = u, i = setTimeout(p, n), x && (e = setTimeout(P, S)), o ? T(u) : d), $ = () => {
+    i !== null && clearTimeout(i), e !== null && clearTimeout(e), s = 0, a = null, g = null, f = null, i = null, e = null;
+  }, L = () => i === null && e === null ? d : C(Date.now()), O = () => i !== null || e !== null, y = function(...u) {
+    const m = Date.now(), h = v(m);
+    if (a = u, g = this, f = m, h) {
+      if (i === null)
+        return b(m);
+      if (x)
+        return clearTimeout(i), i = setTimeout(p, n), T(m);
+    }
+    return i === null && (i = setTimeout(p, n)), d;
+  };
+  return y.cancel = $, y.flush = L, y.pending = O, y;
+}
+function et(t, n, l = {}) {
+  const { leading: o = !0, trailing: r = !0 } = l;
+  return V(t, n, {
+    leading: o,
+    trailing: r,
+    maxWait: n
+  });
+}
 export {
-  g as assignRef,
-  j as cn,
-  _ as createSafeContext,
-  f as formatThousands,
-  E as getFontSize,
-  z as getObjectPath,
-  F as isTextChildren,
-  $ as mergeRefs,
-  T as textFormatter,
-  w as toPascalCase,
-  I as useMergedRef
+  M as assignRef,
+  K as cn,
+  J as createSafeContext,
+  V as debounce,
+  D as formatThousands,
+  G as getFontSize,
+  tt as getObjectPath,
+  Q as isTextChildren,
+  w as mergeRefs,
+  H as textFormatter,
+  et as throttle,
+  q as toPascalCase,
+  Y as useMergedRef
 };

package/dist/lib/debounce/debounce.d.ts

@@ -0,0 +1,57 @@
+export type DebounceOptions = {
+    /**
+     * Invoke on the leading edge of the timeout.
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * Invoke on the trailing edge of the timeout.
+     * @default true
+     */
+    trailing?: boolean;
+    /**
+     * Maximum time func is allowed to be delayed before it's invoked.
+     */
+    maxWait?: number;
+};
+export type DebouncedFunction<T extends (...args: never[]) => unknown> = {
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Cancels any pending invocation.
+     */
+    cancel: () => void;
+    /**
+     * Immediately invokes any pending invocation.
+     */
+    flush: () => ReturnType<T> | undefined;
+    /**
+     * Returns true if there is a pending invocation.
+     */
+    pending: () => boolean;
+};
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with `cancel`, `flush`, and `pending`
+ * methods.
+ *
+ * By default, only `trailing` is enabled:
+ * - `leading`: Invoke immediately on the first call
+ * - `trailing`: Invoke after `wait` ms of no calls
+ * - `maxWait`: Maximum time to wait before forcing invocation
+ *
+ * @example
+ * // Debounce search input to avoid excessive API calls
+ * const debouncedSearch = debounce(search, 300);
+ * input.addEventListener('input', debouncedSearch);
+ *
+ * @example
+ * // Invoke immediately, then debounce subsequent calls
+ * const debounced = debounce(fn, 200, { leading: true });
+ *
+ * @example
+ * // Guarantee invocation at least every 1000ms
+ * const debounced = debounce(fn, 200, { maxWait: 1000 });
+ */
+export declare function debounce<T extends (...args: never[]) => unknown>(func: T, wait: number, options?: DebounceOptions): DebouncedFunction<T>;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/lib/debounce/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../src/lib/debounce/debounce.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,IAAI;IACvE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACpD;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB;;OAEG;IACH,KAAK,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACvC;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAC9D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,iBAAiB,CAAC,CAAC,CAAC,CA0JtB"}

package/dist/lib/debounce/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debounce';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/debounce/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/debounce/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/lib/throttle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './throttle';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/throttle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/throttle/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/lib/throttle/throttle.d.ts

@@ -0,0 +1,41 @@
+import { DebouncedFunction } from '../debounce';
+export type ThrottleOptions = {
+    /**
+     * Invoke on the leading edge of the timeout.
+     * @default true
+     */
+    leading?: boolean;
+    /**
+     * Invoke on the trailing edge of the timeout.
+     * @default true
+     */
+    trailing?: boolean;
+};
+export type ThrottledFunction<T extends (...args: never[]) => unknown> = DebouncedFunction<T>;
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with `cancel`,
+ * `flush`, and `pending` methods.
+ *
+ * Throttle is implemented using debounce with `maxWait` equal to `wait`,
+ * which guarantees the function is invoked at regular intervals.
+ *
+ * By default, both `leading` and `trailing` are enabled:
+ * - `leading`: Invoke immediately on the first call
+ * - `trailing`: Invoke after `wait` ms if called again during the wait period
+ *
+ * @example
+ * // Throttle scroll handler to run at most once every 100ms
+ * const throttledScroll = throttle(handleScroll, 100);
+ * window.addEventListener('scroll', throttledScroll);
+ *
+ * @example
+ * // Only invoke on trailing edge (like debounce but with max frequency)
+ * const throttled = throttle(fn, 200, { leading: false });
+ *
+ * @example
+ * // Only invoke on leading edge (ignore calls during wait period)
+ * const throttled = throttle(fn, 200, { trailing: false });
+ */
+export declare function throttle<T extends (...args: never[]) => unknown>(func: T, wait: number, options?: ThrottleOptions): ThrottledFunction<T>;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/lib/throttle/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../../src/lib/throttle/throttle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,IACnE,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAC9D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,iBAAiB,CAAC,CAAC,CAAC,CAQtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/lumen-utils-shared",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/index.ts

@@ -5,3 +5,5 @@ export * from './lib/cn';
 export * from './lib/isTextChildren';
 export * from './lib/useMergeRef';
 export * from './lib/getObjectPath';
+export * from './lib/throttle';
+export * from './lib/debounce';

package/src/lib/debounce/debounce.ts

@@ -0,0 +1,216 @@
+export type DebounceOptions = {
+  /**
+   * Invoke on the leading edge of the timeout.
+   * @default false
+   */
+  leading?: boolean;
+  /**
+   * Invoke on the trailing edge of the timeout.
+   * @default true
+   */
+  trailing?: boolean;
+  /**
+   * Maximum time func is allowed to be delayed before it's invoked.
+   */
+  maxWait?: number;
+};
+
+export type DebouncedFunction<T extends (...args: never[]) => unknown> = {
+  (...args: Parameters<T>): ReturnType<T> | undefined;
+  /**
+   * Cancels any pending invocation.
+   */
+  cancel: () => void;
+  /**
+   * Immediately invokes any pending invocation.
+   */
+  flush: () => ReturnType<T> | undefined;
+  /**
+   * Returns true if there is a pending invocation.
+   */
+  pending: () => boolean;
+};
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with `cancel`, `flush`, and `pending`
+ * methods.
+ *
+ * By default, only `trailing` is enabled:
+ * - `leading`: Invoke immediately on the first call
+ * - `trailing`: Invoke after `wait` ms of no calls
+ * - `maxWait`: Maximum time to wait before forcing invocation
+ *
+ * @example
+ * // Debounce search input to avoid excessive API calls
+ * const debouncedSearch = debounce(search, 300);
+ * input.addEventListener('input', debouncedSearch);
+ *
+ * @example
+ * // Invoke immediately, then debounce subsequent calls
+ * const debounced = debounce(fn, 200, { leading: true });
+ *
+ * @example
+ * // Guarantee invocation at least every 1000ms
+ * const debounced = debounce(fn, 200, { maxWait: 1000 });
+ */
+export function debounce<T extends (...args: never[]) => unknown>(
+  func: T,
+  wait: number,
+  options: DebounceOptions = {},
+): DebouncedFunction<T> {
+  const { leading = false, trailing = true, maxWait } = options;
+
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+  let maxTimeoutId: ReturnType<typeof setTimeout> | null = null;
+  let lastCallTime: number | null = null;
+  let lastInvokeTime = 0;
+  let lastArgs: Parameters<T> | null = null;
+  let lastThis: unknown = null;
+  let result: ReturnType<T> | undefined;
+
+  const hasMaxWait = maxWait !== undefined;
+  const maxWaitMs = hasMaxWait ? Math.max(maxWait, wait) : 0;
+
+  const invokeFunc = (time: number): ReturnType<T> => {
+    lastInvokeTime = time;
+    const args = lastArgs!;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    result = func.apply(thisArg, args) as ReturnType<T>;
+    return result;
+  };
+
+  const remainingWait = (time: number): number => {
+    const timeSinceLastCall = lastCallTime ? time - lastCallTime : 0;
+    return wait - timeSinceLastCall;
+  };
+
+  const shouldInvoke = (time: number): boolean => {
+    const timeSinceLastCall = lastCallTime ? time - lastCallTime : wait;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+
+    return (
+      lastCallTime === null ||
+      timeSinceLastCall >= wait ||
+      timeSinceLastCall < 0 ||
+      (hasMaxWait && timeSinceLastInvoke >= maxWaitMs)
+    );
+  };
+
+  const trailingEdge = (time: number): ReturnType<T> | undefined => {
+    timeoutId = null;
+
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = null;
+    lastThis = null;
+    return result;
+  };
+
+  const timerExpired = (): void => {
+    const time = Date.now();
+
+    if (shouldInvoke(time)) {
+      trailingEdge(time);
+      return;
+    }
+
+    // Restart the timer with remaining wait
+    timeoutId = setTimeout(timerExpired, remainingWait(time));
+  };
+
+  const maxTimerExpired = (): void => {
+    const time = Date.now();
+    maxTimeoutId = null;
+
+    if (lastArgs) {
+      invokeFunc(time);
+      // Reset the regular timer since we just invoked
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(timerExpired, wait);
+      }
+    }
+  };
+
+  const leadingEdge = (time: number): ReturnType<T> | undefined => {
+    lastInvokeTime = time;
+    timeoutId = setTimeout(timerExpired, wait);
+
+    if (hasMaxWait) {
+      maxTimeoutId = setTimeout(maxTimerExpired, maxWaitMs);
+    }
+
+    if (leading) {
+      return invokeFunc(time);
+    }
+    return result;
+  };
+
+  const cancel = (): void => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    if (maxTimeoutId !== null) {
+      clearTimeout(maxTimeoutId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = null;
+    timeoutId = null;
+    maxTimeoutId = null;
+  };
+
+  const flush = (): ReturnType<T> | undefined => {
+    if (timeoutId === null && maxTimeoutId === null) {
+      return result;
+    }
+    return trailingEdge(Date.now());
+  };
+
+  const pending = (): boolean => {
+    return timeoutId !== null || maxTimeoutId !== null;
+  };
+
+  const debounced = function (
+    this: unknown,
+    ...args: Parameters<T>
+  ): ReturnType<T> | undefined {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+
+    lastArgs = args;
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timeoutId === null) {
+        return leadingEdge(time);
+      }
+      if (hasMaxWait) {
+        // Reset the timer on each call when maxWait is set
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(timerExpired, wait);
+        return invokeFunc(time);
+      }
+    }
+
+    if (timeoutId === null) {
+      timeoutId = setTimeout(timerExpired, wait);
+    }
+
+    return result;
+  } as DebouncedFunction<T>;
+
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  debounced.pending = pending;
+
+  return debounced;
+}

package/src/lib/debounce/index.ts

@@ -0,0 +1 @@
+export * from './debounce';

package/src/lib/throttle/index.ts

@@ -0,0 +1 @@
+export * from './throttle';

package/src/lib/throttle/throttle.ts

@@ -0,0 +1,56 @@
+import { debounce, DebouncedFunction } from '../debounce';
+
+export type ThrottleOptions = {
+  /**
+   * Invoke on the leading edge of the timeout.
+   * @default true
+   */
+  leading?: boolean;
+  /**
+   * Invoke on the trailing edge of the timeout.
+   * @default true
+   */
+  trailing?: boolean;
+};
+
+export type ThrottledFunction<T extends (...args: never[]) => unknown> =
+  DebouncedFunction<T>;
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with `cancel`,
+ * `flush`, and `pending` methods.
+ *
+ * Throttle is implemented using debounce with `maxWait` equal to `wait`,
+ * which guarantees the function is invoked at regular intervals.
+ *
+ * By default, both `leading` and `trailing` are enabled:
+ * - `leading`: Invoke immediately on the first call
+ * - `trailing`: Invoke after `wait` ms if called again during the wait period
+ *
+ * @example
+ * // Throttle scroll handler to run at most once every 100ms
+ * const throttledScroll = throttle(handleScroll, 100);
+ * window.addEventListener('scroll', throttledScroll);
+ *
+ * @example
+ * // Only invoke on trailing edge (like debounce but with max frequency)
+ * const throttled = throttle(fn, 200, { leading: false });
+ *
+ * @example
+ * // Only invoke on leading edge (ignore calls during wait period)
+ * const throttled = throttle(fn, 200, { trailing: false });
+ */
+export function throttle<T extends (...args: never[]) => unknown>(
+  func: T,
+  wait: number,
+  options: ThrottleOptions = {},
+): ThrottledFunction<T> {
+  const { leading = true, trailing = true } = options;
+
+  return debounce(func, wait, {
+    leading,
+    trailing,
+    maxWait: wait,
+  });
+}