@node-edit-utils/core 2.3.2 → 2.3.4

package/src/lib/helpers/withRAF.test.ts

@@ -0,0 +1,439 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { withDoubleRAF, withRAF, withRAFThrottle } from "./withRAF";
+
+describe("withRAF", () => {
+  let rafCallbacks: Map<number, FrameRequestCallback>;
+  let rafIdCounter: number;
+  let originalRAF: typeof requestAnimationFrame;
+  let originalCancelRAF: typeof cancelAnimationFrame;
+
+  beforeEach(() => {
+    rafCallbacks = new Map();
+    rafIdCounter = 0;
+    originalRAF = global.requestAnimationFrame;
+    originalCancelRAF = global.cancelAnimationFrame;
+
+    global.requestAnimationFrame = vi.fn((callback: FrameRequestCallback) => {
+      const id = ++rafIdCounter;
+      rafCallbacks.set(id, callback);
+      return id;
+    }) as unknown as typeof requestAnimationFrame;
+
+    global.cancelAnimationFrame = vi.fn((id: number) => {
+      rafCallbacks.delete(id);
+    }) as unknown as typeof cancelAnimationFrame;
+  });
+
+  afterEach(() => {
+    global.requestAnimationFrame = originalRAF;
+    global.cancelAnimationFrame = originalCancelRAF;
+    rafCallbacks.clear();
+  });
+
+  it("should execute operation on next animation frame", () => {
+    const operation = vi.fn();
+    const cleanup = withRAF(operation);
+
+    expect(operation).not.toHaveBeenCalled();
+
+    // Execute the RAF callback
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(operation).toHaveBeenCalledTimes(1);
+
+    cleanup();
+  });
+
+  it("should return cleanup function", () => {
+    const operation = vi.fn();
+    const cleanup = withRAF(operation);
+
+    expect(typeof cleanup).toBe("function");
+    cleanup();
+  });
+
+  it("should cancel operation when cleanup is called", () => {
+    const operation = vi.fn();
+    const cleanup = withRAF(operation);
+
+    cleanup();
+
+    // Execute any remaining RAF callbacks
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(operation).not.toHaveBeenCalled();
+  });
+
+  it("should execute operation only once", () => {
+    const operation = vi.fn();
+    const cleanup = withRAF(operation);
+
+    // Execute RAF callback once
+    const rafId = Array.from(rafCallbacks.keys())[0];
+    const callback = rafCallbacks.get(rafId);
+    if (callback) {
+      callback(performance.now());
+      rafCallbacks.delete(rafId); // Remove after execution
+    }
+
+    // Try to execute again (should be empty now)
+    rafCallbacks.forEach((cb) => {
+      cb(performance.now());
+    });
+
+    expect(operation).toHaveBeenCalledTimes(1);
+
+    cleanup();
+  });
+});
+
+describe("withRAFThrottle", () => {
+  let rafCallbacks: Map<number, FrameRequestCallback>;
+  let rafIdCounter: number;
+  let originalRAF: typeof requestAnimationFrame;
+  let originalCancelRAF: typeof cancelAnimationFrame;
+
+  beforeEach(() => {
+    rafCallbacks = new Map();
+    rafIdCounter = 0;
+    originalRAF = global.requestAnimationFrame;
+    originalCancelRAF = global.cancelAnimationFrame;
+
+    global.requestAnimationFrame = vi.fn((callback: FrameRequestCallback) => {
+      const id = ++rafIdCounter;
+      rafCallbacks.set(id, callback);
+      return id;
+    }) as unknown as typeof requestAnimationFrame;
+
+    global.cancelAnimationFrame = vi.fn((id: number) => {
+      rafCallbacks.delete(id);
+    }) as unknown as typeof cancelAnimationFrame;
+  });
+
+  afterEach(() => {
+    global.requestAnimationFrame = originalRAF;
+    global.cancelAnimationFrame = originalCancelRAF;
+    rafCallbacks.clear();
+  });
+
+  it("should throttle function calls", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("arg1");
+    throttled("arg2");
+    throttled("arg3");
+
+    expect(func).not.toHaveBeenCalled();
+
+    // Execute RAF callback
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("arg3"); // Should use last args
+  });
+
+  it("should return throttled function with cleanup", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    expect(typeof throttled).toBe("function");
+    expect(typeof throttled.cleanup).toBe("function");
+  });
+
+  it("should cancel pending call on cleanup", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("arg1");
+    throttled.cleanup();
+
+    // Try to execute any remaining RAF callbacks
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).not.toHaveBeenCalled();
+  });
+
+  it("should handle multiple rapid calls", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("call1");
+    throttled("call2");
+    throttled("call3");
+    throttled("call4");
+    throttled("call5");
+
+    // Execute RAF callback
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("call5");
+  });
+
+  it("should allow new calls after previous one executes", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("first");
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("first");
+
+    throttled("second");
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledTimes(2);
+    expect(func).toHaveBeenCalledWith("second");
+  });
+
+  it("should handle function with multiple arguments", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("arg1", "arg2", "arg3");
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledWith("arg1", "arg2", "arg3");
+  });
+
+  it("should reset state on cleanup", () => {
+    const func = vi.fn();
+    const throttled = withRAFThrottle(func);
+
+    throttled("arg1");
+    throttled.cleanup();
+
+    // After cleanup, should be able to call again
+    throttled("arg2");
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).toHaveBeenCalledWith("arg2");
+  });
+});
+
+describe("withDoubleRAF", () => {
+  let rafCallbacks: Map<number, FrameRequestCallback>;
+  let rafIdCounter: number;
+  let originalRAF: typeof requestAnimationFrame;
+  let originalCancelRAF: typeof cancelAnimationFrame;
+
+  beforeEach(() => {
+    rafCallbacks = new Map();
+    rafIdCounter = 0;
+    originalRAF = global.requestAnimationFrame;
+    originalCancelRAF = global.cancelAnimationFrame;
+
+    global.requestAnimationFrame = vi.fn((callback: FrameRequestCallback) => {
+      const id = ++rafIdCounter;
+      rafCallbacks.set(id, callback);
+      return id;
+    }) as unknown as typeof requestAnimationFrame;
+
+    global.cancelAnimationFrame = vi.fn((id: number) => {
+      rafCallbacks.delete(id);
+    }) as unknown as typeof cancelAnimationFrame;
+  });
+
+  afterEach(() => {
+    global.requestAnimationFrame = originalRAF;
+    global.cancelAnimationFrame = originalCancelRAF;
+    rafCallbacks.clear();
+  });
+
+  it("should execute function after two animation frames", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("arg1");
+
+    expect(func).not.toHaveBeenCalled();
+
+    // Execute first RAF (which schedules second RAF)
+    const firstRAFId = Array.from(rafCallbacks.keys())[0];
+    const firstCallback = rafCallbacks.get(firstRAFId);
+    if (firstCallback) {
+      firstCallback(performance.now());
+      rafCallbacks.delete(firstRAFId);
+    }
+    expect(func).not.toHaveBeenCalled();
+
+    // Execute second RAF
+    const secondRAFId = Array.from(rafCallbacks.keys())[0];
+    const secondCallback = rafCallbacks.get(secondRAFId);
+    if (secondCallback) {
+      secondCallback(performance.now());
+    }
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("arg1");
+  });
+
+  it("should return throttled function with cleanup", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    expect(typeof throttled).toBe("function");
+    expect(typeof throttled.cleanup).toBe("function");
+  });
+
+  it("should cancel pending calls on cleanup", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("arg1");
+    throttled.cleanup();
+
+    // Try to execute any remaining RAF callbacks
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).not.toHaveBeenCalled();
+  });
+
+  it("should throttle multiple rapid calls", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("call1");
+    throttled("call2");
+    throttled("call3");
+
+    // Execute first RAF
+    const firstRAFId = Array.from(rafCallbacks.keys())[0];
+    const firstCallback = rafCallbacks.get(firstRAFId);
+    if (firstCallback) {
+      firstCallback(performance.now());
+      rafCallbacks.delete(firstRAFId);
+    }
+
+    // Execute second RAF
+    const secondRAFId = Array.from(rafCallbacks.keys())[0];
+    const secondCallback = rafCallbacks.get(secondRAFId);
+    if (secondCallback) {
+      secondCallback(performance.now());
+    }
+
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("call3");
+  });
+
+  it("should allow new calls after previous one executes", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("first");
+    // Execute double RAF
+    const firstRAFId = Array.from(rafCallbacks.keys())[0];
+    const firstCallback = rafCallbacks.get(firstRAFId);
+    if (firstCallback) {
+      firstCallback(performance.now());
+      rafCallbacks.delete(firstRAFId);
+      const secondRAFId = Array.from(rafCallbacks.keys())[0];
+      const secondCallback = rafCallbacks.get(secondRAFId);
+      if (secondCallback) {
+        secondCallback(performance.now());
+      }
+    }
+
+    expect(func).toHaveBeenCalledTimes(1);
+    expect(func).toHaveBeenCalledWith("first");
+
+    throttled("second");
+    // Execute double RAF again
+    const firstRAFId2 = Array.from(rafCallbacks.keys())[0];
+    const firstCallback2 = rafCallbacks.get(firstRAFId2);
+    if (firstCallback2) {
+      firstCallback2(performance.now());
+      rafCallbacks.delete(firstRAFId2);
+      const secondRAFId2 = Array.from(rafCallbacks.keys())[0];
+      const secondCallback2 = rafCallbacks.get(secondRAFId2);
+      if (secondCallback2) {
+        secondCallback2(performance.now());
+      }
+    }
+
+    expect(func).toHaveBeenCalledTimes(2);
+    expect(func).toHaveBeenCalledWith("second");
+  });
+
+  it("should handle function with multiple arguments", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("arg1", "arg2", "arg3");
+    // Execute double RAF
+    const firstRAFId = Array.from(rafCallbacks.keys())[0];
+    const firstCallback = rafCallbacks.get(firstRAFId);
+    if (firstCallback) {
+      firstCallback(performance.now());
+      rafCallbacks.delete(firstRAFId);
+      const secondRAFId = Array.from(rafCallbacks.keys())[0];
+      const secondCallback = rafCallbacks.get(secondRAFId);
+      if (secondCallback) {
+        secondCallback(performance.now());
+      }
+    }
+
+    expect(func).toHaveBeenCalledWith("arg1", "arg2", "arg3");
+  });
+
+  it("should cancel first RAF if cleanup called before second RAF", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("arg1");
+
+    throttled.cleanup();
+
+    // Try to execute any remaining RAF callbacks
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).not.toHaveBeenCalled();
+  });
+
+  it("should cancel second RAF if cleanup called after first RAF", () => {
+    const func = vi.fn();
+    const throttled = withDoubleRAF(func);
+
+    throttled("arg1");
+
+    // Execute first RAF
+    const firstRAFId = Array.from(rafCallbacks.keys())[0];
+    const firstCallback = rafCallbacks.get(firstRAFId);
+    if (firstCallback) {
+      firstCallback(performance.now());
+      rafCallbacks.delete(firstRAFId);
+    }
+
+    throttled.cleanup();
+
+    // Try to execute any remaining RAF callbacks
+    rafCallbacks.forEach((callback) => {
+      callback(performance.now());
+    });
+
+    expect(func).not.toHaveBeenCalled();
+  });
+});