@adobe/data 0.5.3 → 0.5.5

package/dist/internal/array/topological-sort.test.js

@@ -0,0 +1,100 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+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.*/
+import { describe, it, expect } from "vitest";
+import { topologicalSort } from "./topological-sort.js";
+describe("topologicalSort", () => {
+    it("should sort string nodes in dependency order", () => {
+        const nodes = ["a", "b", "c"];
+        const edges = [["a", "b"], ["b", "c"]]; // a → b → c
+        const result = topologicalSort(nodes, edges);
+        expect(result).toEqual(["a", "b", "c"]);
+    });
+    it("should handle nodes with no dependencies", () => {
+        const nodes = ["x", "y", "z"];
+        const edges = [];
+        const result = topologicalSort(nodes, edges);
+        expect(result).toHaveLength(3);
+        expect(result).toContain("x");
+        expect(result).toContain("y");
+        expect(result).toContain("z");
+    });
+    it("should work with number nodes", () => {
+        const nodes = [1, 2, 3, 4];
+        const edges = [[1, 2], [2, 3], [1, 4]]; // 1 → 2 → 3, 1 → 4
+        const result = topologicalSort(nodes, edges);
+        // Verify ordering constraints
+        expect(result.indexOf(1)).toBeLessThan(result.indexOf(2));
+        expect(result.indexOf(2)).toBeLessThan(result.indexOf(3));
+        expect(result.indexOf(1)).toBeLessThan(result.indexOf(4));
+    });
+    it("should work with object nodes", () => {
+        const nodeA = { name: "a" };
+        const nodeB = { name: "b" };
+        const nodeC = { name: "c" };
+        const nodes = [nodeA, nodeB, nodeC];
+        const edges = [[nodeA, nodeB], [nodeB, nodeC]];
+        const result = topologicalSort(nodes, edges);
+        expect(result).toEqual([nodeA, nodeB, nodeC]);
+    });
+    it("should handle complex dependency graph", () => {
+        const nodes = ["input", "physics", "render", "audio"];
+        const edges = [
+            ["input", "physics"], // input → physics
+            ["physics", "render"], // physics → render
+            ["input", "audio"], // input → audio
+        ];
+        const result = topologicalSort(nodes, edges);
+        // Verify ordering constraints
+        expect(result.indexOf("input")).toBeLessThan(result.indexOf("physics"));
+        expect(result.indexOf("physics")).toBeLessThan(result.indexOf("render"));
+        expect(result.indexOf("input")).toBeLessThan(result.indexOf("audio"));
+    });
+    it("should ignore edges for nodes not in the list", () => {
+        const nodes = ["a", "b"];
+        const edges = [["a", "b"], ["b", "c"], ["c", "d"]]; // c,d not in nodes
+        const result = topologicalSort(nodes, edges);
+        expect(result).toEqual(["a", "b"]);
+    });
+    it("should detect circular dependencies", () => {
+        const nodes = ["a", "b", "c"];
+        const edges = [
+            ["a", "b"],
+            ["b", "c"],
+            ["c", "a"], // creates cycle
+        ];
+        expect(() => topologicalSort(nodes, edges))
+            .toThrow("Circular dependency detected involving node:");
+    });
+    it("should handle single node", () => {
+        const nodes = ["single"];
+        const edges = [];
+        const result = topologicalSort(nodes, edges);
+        expect(result).toEqual(["single"]);
+    });
+    it("should handle empty input", () => {
+        const nodes = [];
+        const edges = [];
+        const result = topologicalSort(nodes, edges);
+        expect(result).toEqual([]);
+    });
+});
+//# sourceMappingURL=topological-sort.test.js.map

package/dist/internal/array/topological-sort.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"topological-sort.test.js","sourceRoot":"","sources":["../../../src/internal/array/topological-sort.test.ts"],"names":[],"mappings":"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"}

package/dist/internal/function/debounce.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Options for configuring debounce behavior
+ */
+export interface DebounceOptions {
+    /**
+     * If true, the function is called on the leading edge of the timeout.
+     * Default: false
+     */
+    readonly leading?: boolean;
+    /**
+     * If true, the function is called on the trailing edge of the timeout.
+     * Default: true
+     */
+    readonly trailing?: boolean;
+    /**
+     * Maximum time function is allowed to be delayed before it's invoked.
+     * If specified, the function will be called at most once per maxWait milliseconds.
+     */
+    readonly maxWait?: number;
+}
+/**
+ * A debounced function with additional control methods
+ */
+export interface DebouncedFunction<TFunc extends (...args: any[]) => any> {
+    /**
+     * The debounced function. Preserves original function signature.
+     */
+    (...args: Parameters<TFunc>): void;
+    /**
+     * Cancel any pending invocation of the debounced function
+     */
+    cancel(): void;
+    /**
+     * Immediately invoke the debounced function and cancel any pending invocation
+     */
+    flush(): ReturnType<TFunc> | undefined;
+    /**
+     * Check if there is a pending invocation of the debounced function
+     */
+    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 methods to cancel delayed `func` invocations
+ * and to flush them immediately.
+ *
+ * @param func - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @param options - The options object for customizing behavior
+ * @returns A debounced function with control methods
+ *
+ * @example
+ * ```typescript
+ * const saveData = (id: string, data: any) => console.log('Saving', id, data);
+ * const debouncedSave = debounce(saveData, 300);
+ *
+ * // Multiple rapid calls - only the last one executes after 300ms
+ * debouncedSave('1', { name: 'test' });
+ * debouncedSave('2', { name: 'test2' }); // This will execute
+ *
+ * // Cancel pending execution
+ * debouncedSave.cancel();
+ *
+ * // Force immediate execution
+ * debouncedSave.flush();
+ * ```
+ */
+export declare const debounce: <TFunc extends (...args: any[]) => any>(func: TFunc, wait: number, options?: DebounceOptions) => DebouncedFunction<TFunc>;

package/dist/internal/function/debounce.js

@@ -0,0 +1,155 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+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.*/
+/**
+ * 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 methods to cancel delayed `func` invocations
+ * and to flush them immediately.
+ *
+ * @param func - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @param options - The options object for customizing behavior
+ * @returns A debounced function with control methods
+ *
+ * @example
+ * ```typescript
+ * const saveData = (id: string, data: any) => console.log('Saving', id, data);
+ * const debouncedSave = debounce(saveData, 300);
+ *
+ * // Multiple rapid calls - only the last one executes after 300ms
+ * debouncedSave('1', { name: 'test' });
+ * debouncedSave('2', { name: 'test2' }); // This will execute
+ *
+ * // Cancel pending execution
+ * debouncedSave.cancel();
+ *
+ * // Force immediate execution
+ * debouncedSave.flush();
+ * ```
+ */
+export const debounce = (func, wait, options = {}) => {
+    const { leading = false, trailing = true, maxWait } = options;
+    let timeoutId;
+    let maxTimeoutId;
+    let lastCallTime;
+    let lastInvokeTime = 0;
+    let lastArgs;
+    let result;
+    const invokeFunc = (time) => {
+        const args = lastArgs;
+        console.log('invokeFunc called with lastArgs:', args);
+        lastArgs = undefined;
+        lastInvokeTime = time;
+        result = func(...args);
+        return result;
+    };
+    const leadingEdge = (time) => {
+        lastInvokeTime = time;
+        timeoutId = setTimeout(timerExpired, wait);
+        if (leading) {
+            invokeFunc(time);
+        }
+    };
+    const timerExpired = () => {
+        const time = Date.now();
+        const timeSinceLastCall = time - (lastCallTime ?? 0);
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        // If we have maxWait active, don't fire the regular timer - let maxWait handle it
+        if (maxTimeoutId !== undefined && maxWait !== undefined && timeSinceLastInvoke < maxWait) {
+            // Still within maxWait period, don't execute yet
+            timeoutId = setTimeout(timerExpired, wait);
+            return;
+        }
+        // Only execute if we've waited long enough
+        if (timeSinceLastCall >= wait) {
+            trailingEdge(time);
+        }
+        else {
+            timeoutId = setTimeout(timerExpired, wait - timeSinceLastCall);
+        }
+    };
+    const trailingEdge = (time) => {
+        timeoutId = undefined;
+        if (maxTimeoutId !== undefined) {
+            clearTimeout(maxTimeoutId);
+            maxTimeoutId = undefined;
+        }
+        if (trailing && lastArgs !== undefined) {
+            invokeFunc(time);
+        }
+        lastArgs = undefined;
+    };
+    const cancel = () => {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (maxTimeoutId !== undefined) {
+            clearTimeout(maxTimeoutId);
+            maxTimeoutId = undefined;
+        }
+        lastInvokeTime = 0;
+        lastCallTime = undefined;
+        lastArgs = undefined;
+        result = undefined;
+    };
+    const flush = () => {
+        if (timeoutId === undefined)
+            return result;
+        const time = Date.now();
+        trailingEdge(time);
+        return result;
+    };
+    const pending = () => {
+        return timeoutId !== undefined;
+    };
+    const debounced = (...args) => {
+        const time = Date.now();
+        lastArgs = args;
+        lastCallTime = time;
+        if (timeoutId === undefined) {
+            leadingEdge(time);
+            // Start maxWait timer if configured
+            if (maxWait !== undefined) {
+                maxTimeoutId = setTimeout(() => {
+                    console.log('maxWait timer fired, lastArgs:', lastArgs);
+                    maxTimeoutId = undefined;
+                    if (timeoutId !== undefined) {
+                        trailingEdge(Date.now());
+                    }
+                }, maxWait);
+            }
+        }
+        else {
+            // Timer is already running, just update the regular timer
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(timerExpired, wait);
+        }
+    };
+    // Attach utility methods to the debounced function
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    debounced.pending = pending;
+    return debounced;
+};
+//# sourceMappingURL=debounce.js.map

package/dist/internal/function/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.js","sourceRoot":"","sources":["../../../src/internal/function/debounce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;WAoBW;AAkDX;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACpB,IAAW,EACX,IAAY,EACZ,UAA2B,EAAE,EACL,EAAE;IAC1B,MAAM,EAAE,OAAO,GAAG,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAE9D,IAAI,SAAoD,CAAC;IACzD,IAAI,YAAuD,CAAC;IAC5D,IAAI,YAAgC,CAAC;IACrC,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,QAAuC,CAAC;IAC5C,IAAI,MAAqC,CAAC;IAE1C,MAAM,UAAU,GAAG,CAAC,IAAY,EAAqB,EAAE;QACnD,MAAM,IAAI,GAAG,QAAS,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,kCAAkC,EAAE,IAAI,CAAC,CAAC;QACtD,QAAQ,GAAG,SAAS,CAAC;QACrB,cAAc,GAAG,IAAI,CAAC;QACtB,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACvB,OAAO,MAA2B,CAAC;IACvC,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,IAAY,EAAQ,EAAE;QACvC,cAAc,GAAG,IAAI,CAAC;QACtB,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QAC3C,IAAI,OAAO,EAAE,CAAC;YACV,UAAU,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,GAAS,EAAE;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACxB,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC;QACrD,MAAM,mBAAmB,GAAG,IAAI,GAAG,cAAc,CAAC;QAElD,kFAAkF;QAClF,IAAI,YAAY,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,IAAI,mBAAmB,GAAG,OAAO,EAAE,CAAC;YACvF,iDAAiD;YACjD,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YAC3C,OAAO;QACX,CAAC;QAED,2CAA2C;QAC3C,IAAI,iBAAiB,IAAI,IAAI,EAAE,CAAC;YAC5B,YAAY,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACJ,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,GAAG,iBAAiB,CAAC,CAAC;QACnE,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,CAAC,IAAY,EAAQ,EAAE;QACxC,SAAS,GAAG,SAAS,CAAC;QACtB,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC7B,YAAY,CAAC,YAAY,CAAC,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;QAC7B,CAAC;QAED,IAAI,QAAQ,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YACrC,UAAU,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;QACD,QAAQ,GAAG,SAAS,CAAC;IACzB,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,GAAS,EAAE;QACtB,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC1B,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,SAAS,GAAG,SAAS,CAAC;QAC1B,CAAC;QACD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC7B,YAAY,CAAC,YAAY,CAAC,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;QAC7B,CAAC;QACD,cAAc,GAAG,CAAC,CAAC;QACnB,YAAY,GAAG,SAAS,CAAC;QACzB,QAAQ,GAAG,SAAS,CAAC;QACrB,MAAM,GAAG,SAAS,CAAC;IACvB,CAAC,CAAC;IAEF,MAAM,KAAK,GAAG,GAAkC,EAAE;QAC9C,IAAI,SAAS,KAAK,SAAS;YAAE,OAAO,MAAM,CAAC;QAE3C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACxB,YAAY,CAAC,IAAI,CAAC,CAAC;QACnB,OAAO,MAAM,CAAC;IAClB,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,GAAY,EAAE;QAC1B,OAAO,SAAS,KAAK,SAAS,CAAC;IACnC,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,CAAC,GAAG,IAAuB,EAAQ,EAAE;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACxB,QAAQ,GAAG,IAAI,CAAC;QAChB,YAAY,GAAG,IAAI,CAAC;QAEpB,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC1B,WAAW,CAAC,IAAI,CAAC,CAAC;YAElB,oCAAoC;YACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBACxB,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE;oBAC3B,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,QAAQ,CAAC,CAAC;oBACxD,YAAY,GAAG,SAAS,CAAC;oBACzB,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;wBAC1B,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;oBAC7B,CAAC;gBACL,CAAC,EAAE,OAAO,CAAC,CAAC;YAChB,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,0DAA0D;YAC1D,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,SAAS,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QAC/C,CAAC;IACL,CAAC,CAAC;IAEF,mDAAmD;IACnD,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC;IAC1B,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC;IACxB,SAAS,CAAC,OAAO,GAAG,OAAO,CAAC;IAE5B,OAAO,SAAqC,CAAC;AACjD,CAAC,CAAC"}

package/dist/internal/function/debounce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/function/debounce.test.js

@@ -0,0 +1,306 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+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.*/
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { debounce } from './debounce.js';
+describe('debounce', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('basic debouncing (trailing edge)', () => {
+        it('should delay function execution', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(99);
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(1);
+            expect(fn).toHaveBeenCalledWith('test');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should only execute the last call when called multiple times rapidly', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('first');
+            debounced('second');
+            debounced('third');
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith('third');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should reset timer on each call', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test1');
+            vi.advanceTimersByTime(50);
+            debounced('test2');
+            vi.advanceTimersByTime(50);
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(50);
+            expect(fn).toHaveBeenCalledWith('test2');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should preserve function arguments with complex types', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            const complexArg = { id: 1, data: [1, 2, 3], nested: { value: 'test' } };
+            debounced('string', 42, complexArg, true);
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith('string', 42, complexArg, true);
+        });
+    });
+    describe('leading edge execution', () => {
+        it('should execute immediately when leading is true', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { leading: true });
+            debounced('test');
+            expect(fn).toHaveBeenCalledWith('test');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should not execute again on trailing edge when leading is true and trailing is false', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { leading: true, trailing: false });
+            debounced('test');
+            expect(fn).toHaveBeenCalledTimes(1);
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should execute both leading and trailing when both are true', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { leading: true, trailing: true });
+            debounced('test1');
+            expect(fn).toHaveBeenCalledWith('test1');
+            debounced('test2');
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith('test2');
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+        it('should not execute on leading edge for subsequent rapid calls', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { leading: true });
+            debounced('first');
+            expect(fn).toHaveBeenCalledTimes(1);
+            debounced('second');
+            debounced('third');
+            expect(fn).toHaveBeenCalledTimes(1); // Still only the leading call
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledTimes(2); // Now trailing edge executes
+            expect(fn).toHaveBeenLastCalledWith('third');
+        });
+    });
+    describe('maxWait functionality', () => {
+        it('should force execution after maxWait time', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { maxWait: 200 });
+            // Add debug logging
+            const originalConsoleLog = console.log;
+            const logs = [];
+            console.log = (...args) => logs.push(args.join(' '));
+            debounced('test1');
+            console.log('Called with test1 at 0ms');
+            vi.advanceTimersByTime(150);
+            console.log('Advanced 150ms');
+            debounced('test2');
+            console.log('Called with test2 at 150ms');
+            vi.advanceTimersByTime(50); // Total 200ms from first call
+            console.log('Advanced final 50ms (total 200ms)');
+            console.log = originalConsoleLog;
+            // Log debug info if test fails
+            if (fn.mock.calls.length > 0) {
+                console.log('Function was called with:', fn.mock.calls[0]);
+                console.log('Debug logs:', logs);
+            }
+            expect(fn).toHaveBeenCalledWith('test2');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should not exceed maxWait even with continuous calls', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100, { maxWait: 250 });
+            // Continuous calls every 50ms
+            for (let i = 0; i < 10; i++) {
+                debounced(`call${i}`);
+                vi.advanceTimersByTime(50);
+                if (i === 4) { // At 250ms total
+                    expect(fn).toHaveBeenCalledTimes(1);
+                    expect(fn).toHaveBeenCalledWith('call4');
+                }
+            }
+        });
+    });
+    describe('cancel method', () => {
+        it('should cancel pending execution', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            expect(debounced.pending()).toBe(true);
+            debounced.cancel();
+            expect(debounced.pending()).toBe(false);
+            vi.advanceTimersByTime(100);
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('should reset internal state', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test1');
+            debounced.cancel();
+            // After cancel, next call should behave like first call
+            debounced('test2');
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith('test2');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('flush method', () => {
+        it('should immediately execute pending function', () => {
+            const fn = vi.fn((x) => `result: ${x}`);
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            const result = debounced.flush();
+            expect(fn).toHaveBeenCalledWith('test');
+            expect(result).toBe('result: test');
+            expect(debounced.pending()).toBe(false);
+        });
+        it('should return undefined if no pending execution', () => {
+            const fn = vi.fn((x) => `result: ${x}`);
+            const debounced = debounce(fn, 100);
+            const result = debounced.flush();
+            expect(result).toBeUndefined();
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('should prevent normal timer execution after flush', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            debounced.flush();
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledTimes(1); // Only from flush, not timer
+        });
+    });
+    describe('pending method', () => {
+        it('should return true when execution is pending', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            expect(debounced.pending()).toBe(false);
+            debounced('test');
+            expect(debounced.pending()).toBe(true);
+            vi.advanceTimersByTime(100);
+            expect(debounced.pending()).toBe(false);
+        });
+        it('should return false after cancel', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            expect(debounced.pending()).toBe(true);
+            debounced.cancel();
+            expect(debounced.pending()).toBe(false);
+        });
+        it('should return false after flush', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            expect(debounced.pending()).toBe(true);
+            debounced.flush();
+            expect(debounced.pending()).toBe(false);
+        });
+    });
+    describe('type safety', () => {
+        it('should preserve function signature for simple functions', () => {
+            const fn = vi.fn((a, b) => `${a}: ${b}`);
+            const debounced = debounce(fn, 100);
+            // Type checking happens at compile time, but we can test runtime behavior
+            debounced('test', 42);
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith('test', 42);
+        });
+        it('should work with functions that return promises', () => {
+            const fn = vi.fn(async (x) => `async result: ${x}`);
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            const result = debounced.flush();
+            expect(result).toBeInstanceOf(Promise);
+        });
+        it('should work with void functions', () => {
+            const fn = vi.fn((x) => {
+                console.log(x);
+            });
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            const result = debounced.flush();
+            expect(result).toBeUndefined();
+            expect(fn).toHaveBeenCalledWith('test');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle zero wait time', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 0);
+            debounced('test');
+            vi.advanceTimersByTime(0);
+            expect(fn).toHaveBeenCalledWith('test');
+        });
+        it('should handle very large wait times', () => {
+            const fn = vi.fn();
+            const debounced = debounce(fn, 1000000);
+            debounced('test');
+            vi.advanceTimersByTime(999999);
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(1);
+            expect(fn).toHaveBeenCalledWith('test');
+        });
+        it('should handle functions with no arguments', () => {
+            const fn = vi.fn(() => 'no args');
+            const debounced = debounce(fn, 100);
+            debounced();
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledWith();
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should handle functions that throw errors', () => {
+            const fn = vi.fn((arg) => {
+                throw new Error('Test error');
+            });
+            const debounced = debounce(fn, 100);
+            debounced('test');
+            expect(() => {
+                vi.advanceTimersByTime(100);
+            }).toThrow('Test error');
+            expect(fn).toHaveBeenCalledWith('test');
+        });
+        it('should handle multiple debounced functions independently', () => {
+            const fn1 = vi.fn();
+            const fn2 = vi.fn();
+            const debounced1 = debounce(fn1, 100);
+            const debounced2 = debounce(fn2, 200);
+            debounced1('test1');
+            debounced2('test2');
+            vi.advanceTimersByTime(100);
+            expect(fn1).toHaveBeenCalledWith('test1');
+            expect(fn2).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(100);
+            expect(fn2).toHaveBeenCalledWith('test2');
+        });
+    });
+});
+//# sourceMappingURL=debounce.test.js.map