ran check:fix in orchestrator

2026-01-25 12:41:44 +00:00
parent ac02a5fd1d
commit 5c2eef2fc8
178 changed files with 12428 additions and 9311 deletions
@@ -1,10 +1,12 @@
-import { useEffect, useState } from 'react';
-import * as api from '../api';
-import type { ResumeProfile } from '../../shared/types';
+import { useEffect, useState } from "react";
+import type { ResumeProfile } from "../../shared/types";
+import * as api from "../api";

 let profileCache: ResumeProfile | null = null;
 let profileError: Error | null = null;
-let subscribers: Set<(profile: ResumeProfile | null, error: Error | null) => void> = new Set();
+const subscribers: Set<
+  (profile: ResumeProfile | null, error: Error | null) => void
+> = new Set();
 let isFetching = false;

 /**
@@ -12,80 +14,84 @@ let isFetching = false;
 * Caches the result to avoid re-fetching.
 */
 export function useProfile() {
-    const [profile, setProfile] = useState<ResumeProfile | null>(profileCache);
-    const [error, setError] = useState<Error | null>(profileError);
+  const [profile, setProfile] = useState<ResumeProfile | null>(profileCache);
+  const [error, setError] = useState<Error | null>(profileError);

-    useEffect(() => {
-        if (profileCache) {
-            setProfile(profileCache);
-        }
-        if (profileError) {
-            setError(profileError);
-        }
+  useEffect(() => {
+    if (profileCache) {
+      setProfile(profileCache);
+    }
+    if (profileError) {
+      setError(profileError);
+    }

-        const handleUpdate = (newProfile: ResumeProfile | null, newError: Error | null) => {
-            setProfile(newProfile);
-            setError(newError);
-        };
-
-        subscribers.add(handleUpdate);
-
-        if (!profileCache && !isFetching) {
-            isFetching = true;
-            profileError = null;
-            api.getProfile()
-                .then((data) => {
-                    profileCache = data;
-                    profileError = null;
-                    subscribers.forEach(sub => sub(data, null));
-                })
-                .catch((err) => {
-                    profileError = err instanceof Error ? err : new Error(String(err));
-                    subscribers.forEach(sub => sub(profileCache, profileError));
-                })
-                .finally(() => {
-                    isFetching = false;
-                });
-        }
-
-        return () => {
-            subscribers.delete(handleUpdate);
-        };
-    }, []);
-
-    const refreshProfile = async () => {
-        isFetching = true;
-        profileError = null;
-        subscribers.forEach(sub => sub(profileCache, null));
-
-        try {
-            const data = await api.getProfile();
-            profileCache = data;
-            profileError = null;
-            subscribers.forEach(sub => sub(data, null));
-            return data;
-        } catch (err) {
-            profileError = err instanceof Error ? err : new Error(String(err));
-            subscribers.forEach(sub => sub(profileCache, profileError));
-            throw profileError;
-        } finally {
-            isFetching = false;
-        }
+    const handleUpdate = (
+      newProfile: ResumeProfile | null,
+      newError: Error | null,
+    ) => {
+      setProfile(newProfile);
+      setError(newError);
    };

-    return {
-        profile,
-        error,
-        isLoading: !profile && isFetching && !error,
-        personName: profile?.basics?.name || 'Resume',
-        refreshProfile,
+    subscribers.add(handleUpdate);
+
+    if (!profileCache && !isFetching) {
+      isFetching = true;
+      profileError = null;
+      api
+        .getProfile()
+        .then((data) => {
+          profileCache = data;
+          profileError = null;
+          subscribers.forEach((sub) => sub(data, null));
+        })
+        .catch((err) => {
+          profileError = err instanceof Error ? err : new Error(String(err));
+          subscribers.forEach((sub) => sub(profileCache, profileError));
+        })
+        .finally(() => {
+          isFetching = false;
+        });
+    }
+
+    return () => {
+      subscribers.delete(handleUpdate);
    };
+  }, []);
+
+  const refreshProfile = async () => {
+    isFetching = true;
+    profileError = null;
+    subscribers.forEach((sub) => sub(profileCache, null));
+
+    try {
+      const data = await api.getProfile();
+      profileCache = data;
+      profileError = null;
+      subscribers.forEach((sub) => sub(data, null));
+      return data;
+    } catch (err) {
+      profileError = err instanceof Error ? err : new Error(String(err));
+      subscribers.forEach((sub) => sub(profileCache, profileError));
+      throw profileError;
+    } finally {
+      isFetching = false;
+    }
+  };
+
+  return {
+    profile,
+    error,
+    isLoading: !profile && isFetching && !error,
+    personName: profile?.basics?.name || "Resume",
+    refreshProfile,
+  };
 }

 /** @internal For testing only */
 export function _resetProfileCache() {
-    profileCache = null;
-    profileError = null;
-    isFetching = false;
-    subscribers.clear();
+  profileCache = null;
+  profileError = null;
+  isFetching = false;
+  subscribers.clear();
 }
@@ -1,9 +1,8 @@
 import { act, renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { useRescoreJob } from "./useRescoreJob";
-import * as api from "../api";
 import { toast } from "sonner";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "../api";
+import { useRescoreJob } from "./useRescoreJob";

 vi.mock("../api", () => ({
  rescoreJob: vi.fn(),
@@ -16,7 +16,10 @@ export function useRescoreJob(onJobUpdated: () => void | Promise<void>) {
        toast.success("Match recalculated");
        await onJobUpdated();
      } catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to recalculate match";
+        const message =
+          error instanceof Error
+            ? error.message
+            : "Failed to recalculate match";
        toast.error(message);
      } finally {
        setIsRescoring(false);
@@ -1,80 +1,80 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { useSettings, _resetSettingsCache } from './useSettings';
-import * as api from '../api';
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "../api";
+import { _resetSettingsCache, useSettings } from "./useSettings";

-vi.mock('../api', () => ({
-    getSettings: vi.fn(),
+vi.mock("../api", () => ({
+  getSettings: vi.fn(),
 }));

-describe('useSettings', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        _resetSettingsCache();
+describe("useSettings", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    _resetSettingsCache();
+  });
+
+  it("fetches settings on mount if not already cached", async () => {
+    const mockSettings = { showSponsorInfo: false };
+    (api.getSettings as any).mockResolvedValue(mockSettings);
+
+    const { result } = renderHook(() => useSettings());
+
+    // Should start in loading state
+    expect(result.current.settings).toBeNull();
+
+    await waitFor(() => {
+      expect(result.current.settings).toEqual(mockSettings);
    });

-    it('fetches settings on mount if not already cached', async () => {
-        const mockSettings = { showSponsorInfo: false };
-        (api.getSettings as any).mockResolvedValue(mockSettings);
+    expect(result.current.showSponsorInfo).toBe(false);
+    expect(api.getSettings).toHaveBeenCalledTimes(1);
+  });

-        const { result } = renderHook(() => useSettings());
+  it("uses default values when settings are null", async () => {
+    (api.getSettings as any).mockResolvedValue(null);

-        // Should start in loading state
-        expect(result.current.settings).toBeNull();
+    const { result } = renderHook(() => useSettings());

-        await waitFor(() => {
-            expect(result.current.settings).toEqual(mockSettings);
-        });
+    await waitFor(() => {
+      // settings is null, so showSponsorInfo should default to true
+      expect(result.current.showSponsorInfo).toBe(true);
+    });
+  });

-        expect(result.current.showSponsorInfo).toBe(false);
-        expect(api.getSettings).toHaveBeenCalledTimes(1);
+  it("provides a refresh function that updates settings", async () => {
+    const initialSettings = { showSponsorInfo: true };
+    const updatedSettings = { showSponsorInfo: false };
+
+    (api.getSettings as any).mockResolvedValueOnce(initialSettings);
+    (api.getSettings as any).mockResolvedValueOnce(updatedSettings);
+
+    const { result } = renderHook(() => useSettings());
+
+    await waitFor(() => {
+      expect(result.current.settings).toEqual(initialSettings);
    });

-    it('uses default values when settings are null', async () => {
-        (api.getSettings as any).mockResolvedValue(null);
-
-        const { result } = renderHook(() => useSettings());
-
-        await waitFor(() => {
-            // settings is null, so showSponsorInfo should default to true
-            expect(result.current.showSponsorInfo).toBe(true);
-        });
+    let refreshed;
+    await waitFor(async () => {
+      refreshed = await result.current.refreshSettings();
    });

-    it('provides a refresh function that updates settings', async () => {
-        const initialSettings = { showSponsorInfo: true };
-        const updatedSettings = { showSponsorInfo: false };
+    expect(refreshed).toEqual(updatedSettings);
+    expect(result.current.settings).toEqual(updatedSettings);
+    expect(result.current.showSponsorInfo).toBe(false);
+  });

-        (api.getSettings as any).mockResolvedValueOnce(initialSettings);
-        (api.getSettings as any).mockResolvedValueOnce(updatedSettings);
+  it("handles errors when fetching settings", async () => {
+    const mockError = new Error("Failed to fetch");
+    (api.getSettings as any).mockRejectedValue(mockError);

-        const { result } = renderHook(() => useSettings());
+    const { result } = renderHook(() => useSettings());

-        await waitFor(() => {
-            expect(result.current.settings).toEqual(initialSettings);
-        });
-
-        let refreshed;
-        await waitFor(async () => {
-            refreshed = await result.current.refreshSettings();
-        });
-
-        expect(refreshed).toEqual(updatedSettings);
-        expect(result.current.settings).toEqual(updatedSettings);
-        expect(result.current.showSponsorInfo).toBe(false);
+    await waitFor(() => {
+      expect(result.current.error).toEqual(mockError);
    });

-    it('handles errors when fetching settings', async () => {
-        const mockError = new Error('Failed to fetch');
-        (api.getSettings as any).mockRejectedValue(mockError);
-
-        const { result } = renderHook(() => useSettings());
-
-        await waitFor(() => {
-            expect(result.current.error).toEqual(mockError);
-        });
-
-        expect(result.current.isLoading).toBe(false);
-        expect(result.current.settings).toBeNull();
-    });
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.settings).toBeNull();
+  });
 });
@@ -1,87 +1,93 @@
-import { useEffect, useState } from 'react';
-import type { AppSettings } from '../../shared/types';
-import * as api from '../api';
+import { useEffect, useState } from "react";
+import type { AppSettings } from "../../shared/types";
+import * as api from "../api";

 let settingsCache: AppSettings | null = null;
 let settingsError: Error | null = null;
-let subscribers: Set<(settings: AppSettings | null, error: Error | null) => void> = new Set();
+const subscribers: Set<
+  (settings: AppSettings | null, error: Error | null) => void
+> = new Set();
 let isFetching = false;

 export function useSettings() {
-    const [settings, setSettings] = useState<AppSettings | null>(settingsCache);
-    const [error, setError] = useState<Error | null>(settingsError);
+  const [settings, setSettings] = useState<AppSettings | null>(settingsCache);
+  const [error, setError] = useState<Error | null>(settingsError);

-    useEffect(() => {
-        if (settingsCache) {
-            setSettings(settingsCache);
-        }
-        if (settingsError) {
-            setError(settingsError);
-        }
+  useEffect(() => {
+    if (settingsCache) {
+      setSettings(settingsCache);
+    }
+    if (settingsError) {
+      setError(settingsError);
+    }

-        const handleUpdate = (newSettings: AppSettings | null, newError: Error | null) => {
-            setSettings(newSettings);
-            setError(newError);
-        };
-
-        subscribers.add(handleUpdate);
-
-        if (!settingsCache && !isFetching) {
-            isFetching = true;
-            settingsError = null;
-            api.getSettings()
-                .then((data) => {
-                    settingsCache = data;
-                    settingsError = null;
-                    subscribers.forEach(sub => sub(data, null));
-                })
-                .catch((err) => {
-                    settingsError = err instanceof Error ? err : new Error(String(err));
-                    subscribers.forEach(sub => sub(settingsCache, settingsError));
-                })
-                .finally(() => {
-                    isFetching = false;
-                });
-        }
-
-        return () => {
-            subscribers.delete(handleUpdate);
-        };
-    }, []);
-
-    const refreshSettings = async () => {
-        isFetching = true;
-        settingsError = null;
-        subscribers.forEach(sub => sub(settingsCache, null));
-
-        try {
-            const data = await api.getSettings();
-            settingsCache = data;
-            settingsError = null;
-            subscribers.forEach(sub => sub(data, null));
-            return data;
-        } catch (err) {
-            settingsError = err instanceof Error ? err : new Error(String(err));
-            subscribers.forEach(sub => sub(settingsCache, settingsError));
-            throw settingsError;
-        } finally {
-            isFetching = false;
-        }
+    const handleUpdate = (
+      newSettings: AppSettings | null,
+      newError: Error | null,
+    ) => {
+      setSettings(newSettings);
+      setError(newError);
    };

-    return {
-        settings,
-        error,
-        isLoading: !settings && isFetching && !error,
-        showSponsorInfo: settings?.showSponsorInfo ?? true,
-        refreshSettings,
+    subscribers.add(handleUpdate);
+
+    if (!settingsCache && !isFetching) {
+      isFetching = true;
+      settingsError = null;
+      api
+        .getSettings()
+        .then((data) => {
+          settingsCache = data;
+          settingsError = null;
+          subscribers.forEach((sub) => sub(data, null));
+        })
+        .catch((err) => {
+          settingsError = err instanceof Error ? err : new Error(String(err));
+          subscribers.forEach((sub) => sub(settingsCache, settingsError));
+        })
+        .finally(() => {
+          isFetching = false;
+        });
+    }
+
+    return () => {
+      subscribers.delete(handleUpdate);
    };
+  }, []);
+
+  const refreshSettings = async () => {
+    isFetching = true;
+    settingsError = null;
+    subscribers.forEach((sub) => sub(settingsCache, null));
+
+    try {
+      const data = await api.getSettings();
+      settingsCache = data;
+      settingsError = null;
+      subscribers.forEach((sub) => sub(data, null));
+      return data;
+    } catch (err) {
+      settingsError = err instanceof Error ? err : new Error(String(err));
+      subscribers.forEach((sub) => sub(settingsCache, settingsError));
+      throw settingsError;
+    } finally {
+      isFetching = false;
+    }
+  };
+
+  return {
+    settings,
+    error,
+    isLoading: !settings && isFetching && !error,
+    showSponsorInfo: settings?.showSponsorInfo ?? true,
+    refreshSettings,
+  };
 }

 /** @internal For testing only */
 export function _resetSettingsCache() {
-    settingsCache = null;
-    settingsError = null;
-    isFetching = false;
-    subscribers.clear();
+  settingsCache = null;
+  settingsError = null;
+  isFetching = false;
+  subscribers.clear();
 }