Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

feat(resume-export): add useResumePdfPreview hook with debounced, cached blob generation

Khuram Niaz473e4f9e7b0d
diff --git a/__tests__/useResumePdfPreview.spec.ts b/__tests__/useResumePdfPreview.spec.ts
new file mode 100644
index 0000000..3855b67
--- /dev/null
+++ b/__tests__/useResumePdfPreview.spec.ts
@@ -0,0 +1,186 @@
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ContactInfo, Resume } from "@/models/profile.model";
+import type { ResumeExportSettings } from "@/models/resumeExport.model";
+
+const { generateResumePdfBlob } = vi.hoisted(() => ({
+ generateResumePdfBlob: vi.fn(),
+}));
+
+// The hook reaches the generator through `await import("../resume-pdf")`;
+// both specifiers resolve to the same module id, so this intercepts it.
+vi.mock("@/components/profile/resume-pdf", () => ({ generateResumePdfBlob }));
+
+// canExportResume lives beside the export hook, which pulls the router and
+// the toast layer at module scope. Neither is exercised here.
+vi.mock("next/navigation", () => ({
+ useRouter: () => ({ refresh: vi.fn() }),
+}));
+vi.mock("@/lib/toast", () => ({
+ toastError: vi.fn(),
+ toastSuccess: vi.fn(),
+}));
+
+import { useResumePdfPreview } from "@/components/profile/resume-container/useResumePdfPreview";
+
+const resume: Resume = {
+ id: "r1",
+ title: "My Resume",
+ ContactInfo: { firstName: "Ada", lastName: "Lovelace" } as ContactInfo,
+};
+
+const emptyResume: Resume = { id: "r2", title: "Untouched" };
+
+const simple: ResumeExportSettings = { template: "simple" };
+const professional: ResumeExportSettings = { template: "professional" };
+
+// Flushes pending microtasks (the dynamic import) and any expired timers.
+const flush = (ms = 0) =>
+ act(async () => {
+ await vi.advanceTimersByTimeAsync(ms);
+ });
+
+describe("useResumePdfPreview", () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ generateResumePdfBlob.mockReset();
+ generateResumePdfBlob.mockImplementation(
+ async (_resume: Resume, settings: ResumeExportSettings) => ({
+ blob: new Blob([settings.template], { type: "application/pdf" }),
+ filename: `My Resume - ${settings.template}.pdf`,
+ }),
+ );
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it("generates immediately when the dialog opens", async () => {
+ const { result } = renderHook(() =>
+ useResumePdfPreview(resume, simple, true),
+ );
+
+ await flush();
+
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(1);
+ expect(generateResumePdfBlob).toHaveBeenCalledWith(resume, simple);
+ expect(result.current.blob).toBeInstanceOf(Blob);
+ expect(result.current.filename).toBe("My Resume - simple.pdf");
+ expect(result.current.isGenerating).toBe(false);
+ expect(result.current.error).toBeNull();
+ });
+
+ it("generates nothing while the dialog is closed", async () => {
+ const { result } = renderHook(() =>
+ useResumePdfPreview(resume, simple, false),
+ );
+
+ await flush();
+
+ expect(generateResumePdfBlob).not.toHaveBeenCalled();
+ expect(result.current.blob).toBeNull();
+ expect(result.current.isGenerating).toBe(false);
+ });
+
+ it("generates nothing for a resume with no exportable content", async () => {
+ const { result } = renderHook(() =>
+ useResumePdfPreview(emptyResume, simple, true),
+ );
+
+ await flush();
+
+ expect(generateResumePdfBlob).not.toHaveBeenCalled();
+ expect(result.current.blob).toBeNull();
+ expect(result.current.isGenerating).toBe(false);
+ expect(result.current.error).toBeNull();
+ });
+
+ it("debounces a settings change by 250ms", async () => {
+ const { rerender } = renderHook(
+ ({ settings }: { settings: ResumeExportSettings }) =>
+ useResumePdfPreview(resume, settings, true),
+ { initialProps: { settings: simple } },
+ );
+ await flush();
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(1);
+
+ rerender({ settings: professional });
+ await flush(200);
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(1);
+
+ await flush(50);
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(2);
+ expect(generateResumePdfBlob).toHaveBeenLastCalledWith(resume, professional);
+ });
+
+ it("coalesces a burst of settings changes into one generation", async () => {
+ const { rerender } = renderHook(
+ ({ settings }: { settings: ResumeExportSettings }) =>
+ useResumePdfPreview(resume, settings, true),
+ { initialProps: { settings: simple } },
+ );
+ await flush();
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(1);
+
+ // simple is already cached, so the middle rerender resolves instantly and
+ // cancels the pending professional timer; only the last one survives.
+ rerender({ settings: professional });
+ rerender({ settings: simple });
+ rerender({ settings: professional });
+ await flush(250);
+
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(2);
+ expect(generateResumePdfBlob).toHaveBeenLastCalledWith(resume, professional);
+ });
+
+ it("serves an already-rendered configuration from cache", async () => {
+ const { result, rerender } = renderHook(
+ ({ settings }: { settings: ResumeExportSettings }) =>
+ useResumePdfPreview(resume, settings, true),
+ { initialProps: { settings: simple } },
+ );
+ await flush();
+
+ rerender({ settings: professional });
+ await flush(250);
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(2);
+ expect(result.current.filename).toBe("My Resume - professional.pdf");
+
+ rerender({ settings: simple });
+ await flush(250);
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(2);
+ expect(result.current.filename).toBe("My Resume - simple.pdf");
+ expect(result.current.isGenerating).toBe(false);
+ });
+
+ it("clears the cache when the dialog closes", async () => {
+ const { result, rerender } = renderHook(
+ ({ open }: { open: boolean }) => useResumePdfPreview(resume, simple, open),
+ { initialProps: { open: true } },
+ );
+ await flush();
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(1);
+
+ rerender({ open: false });
+ await flush();
+ expect(result.current.blob).toBeNull();
+
+ rerender({ open: true });
+ await flush();
+ expect(generateResumePdfBlob).toHaveBeenCalledTimes(2);
+ });
+
+ it("surfaces a generation failure as an error and stops generating", async () => {
+ generateResumePdfBlob.mockRejectedValueOnce(new Error("boom"));
+
+ const { result } = renderHook(() =>
+ useResumePdfPreview(resume, simple, true),
+ );
+ await flush();
+
+ expect(result.current.error).toBeInstanceOf(Error);
+ expect(result.current.blob).toBeNull();
+ expect(result.current.isGenerating).toBe(false);
+ });
+});
diff --git a/src/components/profile/resume-container/useResumePdfPreview.ts b/src/components/profile/resume-container/useResumePdfPreview.ts
new file mode 100644
index 0000000..ee4e397
--- /dev/null
+++ b/src/components/profile/resume-container/useResumePdfPreview.ts
@@ -0,0 +1,108 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+import type { Resume } from "@/models/profile.model";
+import type { ResumeExportSettings } from "@/models/resumeExport.model";
+import { canExportResume } from "./useResumePdfExport";
+
+const PREVIEW_DEBOUNCE_MS = 250;
+
+type PreviewResult = { blob: Blob; filename: string };
+
+// Owns the preview artifact: debounce, cache, and blob generation. Deliberately
+// touches no canvas and creates no object URL — PdfPreviewPane owns rendering.
+export function useResumePdfPreview(
+ resume: Resume,
+ settings: ResumeExportSettings,
+ open: boolean,
+) {
+ const [result, setResult] = useState<PreviewResult | null>(null);
+ const [isGenerating, setIsGenerating] = useState(false);
+ const [error, setError] = useState<Error | null>(null);
+
+ const cacheRef = useRef(new Map<string, PreviewResult>());
+ const hasRenderedRef = useRef(false);
+ const runIdRef = useRef(0);
+
+ // Read through refs so the effect can depend on primitives only.
+ const resumeRef = useRef(resume);
+ resumeRef.current = resume;
+ const settingsRef = useRef(settings);
+ settingsRef.current = settings;
+
+ // Insertion-order sensitive. Fine while settings come from one literal;
+ // revisit the day a setting arrives by spread or merge.
+ const key = JSON.stringify(settings);
+ const canExport = canExportResume(resume);
+
+ useEffect(() => {
+ if (!open) {
+ // A resume edited between openings must never show a stale preview.
+ cacheRef.current.clear();
+ hasRenderedRef.current = false;
+ runIdRef.current += 1;
+ setResult(null);
+ setIsGenerating(false);
+ setError(null);
+ return;
+ }
+
+ if (!canExport) {
+ runIdRef.current += 1;
+ setResult(null);
+ setIsGenerating(false);
+ setError(null);
+ return;
+ }
+
+ const cached = cacheRef.current.get(key);
+ if (cached) {
+ runIdRef.current += 1;
+ hasRenderedRef.current = true;
+ setResult(cached);
+ setIsGenerating(false);
+ setError(null);
+ return;
+ }
+
+ const runId = ++runIdRef.current;
+ setIsGenerating(true);
+ setError(null);
+
+ const generate = async () => {
+ try {
+ const { generateResumePdfBlob } = await import("../resume-pdf");
+ const generated = await generateResumePdfBlob(
+ resumeRef.current,
+ settingsRef.current,
+ );
+ if (runIdRef.current !== runId) return;
+ cacheRef.current.set(key, generated);
+ setResult(generated);
+ setError(null);
+ } catch (e) {
+ if (runIdRef.current !== runId) return;
+ setResult(null);
+ setError(e instanceof Error ? e : new Error("Preview failed"));
+ } finally {
+ if (runIdRef.current === runId) setIsGenerating(false);
+ }
+ };
+
+ // Opening the dialog must not wait out a debounce nobody triggered.
+ if (!hasRenderedRef.current) {
+ hasRenderedRef.current = true;
+ void generate();
+ return;
+ }
+
+ const timer = setTimeout(() => void generate(), PREVIEW_DEBOUNCE_MS);
+ return () => clearTimeout(timer);
+ }, [open, key, canExport]);
+
+ return {
+ blob: result?.blob ?? null,
+ filename: result?.filename ?? null,
+ isGenerating,
+ error,
+ };
+}