@sonhoseong/mfa-lib 1.3.7 → 1.3.10

package/dist/hooks/use-recent-menu.js

@@ -0,0 +1,169 @@
+/**
+ * useRecentMenu Hook
+ * 최근 방문 메뉴 상태 저장/복구
+ */
+import { useCallback, useEffect, useRef } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { useLocation, useNavigate } from 'react-router-dom';
+import { addRecentMenu, removeRecentMenu, setCurrentRecentMenu, updateRecentMenuState, clearRecentMenu, closeOtherMenus, setRecentMenuList, selectRecentMenuList, selectCurrentRecentMenu, selectCurrentRecentMenuId, } from '../store/recent-menu-slice';
+import { storage } from '../utils/storage';
+/**
+ * useRecentMenu Hook
+ */
+export function useRecentMenu(options = {}) {
+    const { autoTrack = false, excludePaths = ['/login', '/error'], getTitleFromPath = (pathname) => pathname.split('/').pop() || 'Home', } = options;
+    const dispatch = useDispatch();
+    const location = useLocation();
+    const navigate = useNavigate();
+    const recentMenuList = useSelector(selectRecentMenuList);
+    const currentMenu = useSelector(selectCurrentRecentMenu);
+    const currentMenuId = useSelector(selectCurrentRecentMenuId);
+    // 이전 위치 저장 (상태 저장용)
+    const prevLocationRef = useRef(location);
+    /**
+     * 초기화: localStorage에서 복구
+     */
+    useEffect(() => {
+        const saved = storage.getRecentMenu();
+        if (saved && saved.length > 0) {
+            dispatch(setRecentMenuList(saved));
+        }
+    }, [dispatch]);
+    /**
+     * 자동 추적 모드: 경로 변경 시 자동으로 추가
+     */
+    useEffect(() => {
+        if (!autoTrack)
+            return;
+        // 제외 경로 체크
+        const isExcluded = excludePaths.some((pattern) => {
+            if (typeof pattern === 'string') {
+                return location.pathname === pattern || location.pathname.startsWith(pattern);
+            }
+            return pattern.test(location.pathname);
+        });
+        if (isExcluded)
+            return;
+        // 메뉴 ID 생성 (pathname + search 기반)
+        const menuId = `${location.pathname}${location.search}`;
+        // 현재 경로를 최근 메뉴에 추가
+        dispatch(addRecentMenu({
+            id: menuId,
+            pathname: location.pathname,
+            search: location.search,
+            title: getTitleFromPath(location.pathname),
+        }));
+    }, [autoTrack, location.pathname, location.search, dispatch, excludePaths, getTitleFromPath]);
+    /**
+     * 이전 페이지 상태 저장 (페이지 이탈 시)
+     */
+    useEffect(() => {
+        const prevLocation = prevLocationRef.current;
+        if (prevLocation.pathname !== location.pathname) {
+            // 이전 페이지의 스크롤 위치 저장
+            const prevMenuId = `${prevLocation.pathname}${prevLocation.search}`;
+            dispatch(updateRecentMenuState({
+                id: prevMenuId,
+                state: {
+                    scrollY: window.scrollY,
+                    scrollX: window.scrollX,
+                },
+            }));
+        }
+        prevLocationRef.current = location;
+    }, [location, dispatch]);
+    /**
+     * 메뉴 추가
+     */
+    const add = useCallback((menu) => {
+        const id = menu.id || `${menu.pathname}${menu.search || ''}`;
+        dispatch(addRecentMenu({ ...menu, id }));
+    }, [dispatch]);
+    /**
+     * 메뉴 제거
+     */
+    const remove = useCallback((id) => {
+        dispatch(removeRecentMenu(id));
+    }, [dispatch]);
+    /**
+     * 현재 메뉴 변경
+     */
+    const setCurrent = useCallback((id) => {
+        dispatch(setCurrentRecentMenu(id));
+    }, [dispatch]);
+    /**
+     * 메뉴로 이동
+     */
+    const goTo = useCallback((id) => {
+        const menu = recentMenuList.find((m) => m.id === id);
+        if (menu) {
+            dispatch(setCurrentRecentMenu(id));
+            navigate(`${menu.pathname}${menu.search || ''}`);
+            // 저장된 스크롤 위치 복구
+            if (menu.state?.scrollY !== undefined) {
+                setTimeout(() => {
+                    window.scrollTo(menu.state.scrollX || 0, menu.state.scrollY);
+                }, 100);
+            }
+        }
+    }, [recentMenuList, dispatch, navigate]);
+    /**
+     * 메뉴 상태 업데이트 (검색 조건, 선택된 항목 등)
+     */
+    const updateState = useCallback((id, state) => {
+        dispatch(updateRecentMenuState({ id, state }));
+    }, [dispatch]);
+    /**
+     * 메뉴 데이터 업데이트
+     */
+    const updateData = useCallback((id, data) => {
+        dispatch(updateRecentMenuState({ id, data }));
+    }, [dispatch]);
+    /**
+     * 현재 메뉴 상태 업데이트
+     */
+    const updateCurrentState = useCallback((state) => {
+        if (currentMenuId) {
+            dispatch(updateRecentMenuState({ id: currentMenuId, state }));
+        }
+    }, [currentMenuId, dispatch]);
+    /**
+     * 모든 메뉴 닫기
+     */
+    const closeAll = useCallback(() => {
+        dispatch(clearRecentMenu());
+    }, [dispatch]);
+    /**
+     * 다른 메뉴 모두 닫기
+     */
+    const closeOthers = useCallback(() => {
+        dispatch(closeOtherMenus());
+    }, [dispatch]);
+    return {
+        /** 최근 메뉴 목록 */
+        list: recentMenuList,
+        /** 현재 활성 메뉴 */
+        current: currentMenu,
+        /** 현재 활성 메뉴 ID */
+        currentId: currentMenuId,
+        /** 메뉴 추가 */
+        add,
+        /** 메뉴 제거 */
+        remove,
+        /** 현재 메뉴 설정 */
+        setCurrent,
+        /** 메뉴로 이동 */
+        goTo,
+        /** 메뉴 상태 업데이트 */
+        updateState,
+        /** 메뉴 데이터 업데이트 */
+        updateData,
+        /** 현재 메뉴 상태 업데이트 */
+        updateCurrentState,
+        /** 모든 메뉴 닫기 */
+        closeAll,
+        /** 다른 메뉴 모두 닫기 */
+        closeOthers,
+    };
+}
+export default useRecentMenu;

package/dist/hooks/use-scroll-restoration.d.ts

@@ -0,0 +1,51 @@
+export interface ScrollRestorationOptions {
+    /** 스크롤 복원 활성화 여부 */
+    enabled?: boolean;
+    /** 스크롤 복원 동작 */
+    behavior?: ScrollBehavior;
+    /** 새 페이지 진입 시 상단으로 스크롤 */
+    scrollToTopOnNewPage?: boolean;
+    /** 스크롤 복원 제외 경로 */
+    excludePaths?: string[];
+    /** 스크롤 대상 요소 (기본: window) */
+    scrollElement?: HTMLElement | null;
+}
+/**
+ * useScrollRestoration
+ * 페이지 이동 시 스크롤 위치를 자동으로 저장하고 복원
+ *
+ * @example
+ * function App() {
+ *   useScrollRestoration();
+ *   return <Routes>...</Routes>;
+ * }
+ *
+ * @example
+ * // 커스텀 설정
+ * useScrollRestoration({
+ *   behavior: 'smooth',
+ *   excludePaths: ['/modal'],
+ *   scrollToTopOnNewPage: true,
+ * });
+ */
+export declare function useScrollRestoration(options?: ScrollRestorationOptions): {
+    saveScrollPosition: () => void;
+    restoreScrollPosition: () => boolean;
+    scrollToTop: () => void;
+    clearScrollPositions: () => void;
+};
+/**
+ * useScrollToTop
+ * 페이지 이동 시 항상 상단으로 스크롤
+ *
+ * @example
+ * function App() {
+ *   useScrollToTop();
+ *   return <Routes>...</Routes>;
+ * }
+ */
+export declare function useScrollToTop(options?: {
+    behavior?: ScrollBehavior;
+}): void;
+export default useScrollRestoration;
+//# sourceMappingURL=use-scroll-restoration.d.ts.map

package/dist/hooks/use-scroll-restoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scroll-restoration.d.ts","sourceRoot":"","sources":["../../src/hooks/use-scroll-restoration.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,wBAAwB;IACvC,oBAAoB;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,0BAA0B;IAC1B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,mBAAmB;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,6BAA6B;IAC7B,aAAa,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,wBAA6B;;;;;EAuH1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAO,QAOzE;AAED,eAAe,oBAAoB,CAAC"}

package/dist/hooks/use-scroll-restoration.js

@@ -0,0 +1,143 @@
+/**
+ * 스크롤 복원 Hook
+ * 페이지 이동 시 스크롤 위치를 저장하고 복원
+ */
+import { useEffect, useRef, useCallback } from 'react';
+import { useLocation } from 'react-router-dom';
+// 스크롤 위치 저장소
+const scrollPositions = new Map();
+/**
+ * useScrollRestoration
+ * 페이지 이동 시 스크롤 위치를 자동으로 저장하고 복원
+ *
+ * @example
+ * function App() {
+ *   useScrollRestoration();
+ *   return <Routes>...</Routes>;
+ * }
+ *
+ * @example
+ * // 커스텀 설정
+ * useScrollRestoration({
+ *   behavior: 'smooth',
+ *   excludePaths: ['/modal'],
+ *   scrollToTopOnNewPage: true,
+ * });
+ */
+export function useScrollRestoration(options = {}) {
+    const { enabled = true, behavior = 'auto', scrollToTopOnNewPage = true, excludePaths = [], scrollElement = null, } = options;
+    const location = useLocation();
+    const prevPathRef = useRef(null);
+    const isRestoringRef = useRef(false);
+    // 스크롤 위치 가져오기
+    const getScrollPosition = useCallback(() => {
+        if (scrollElement) {
+            return scrollElement.scrollTop;
+        }
+        return window.scrollY || document.documentElement.scrollTop;
+    }, [scrollElement]);
+    // 스크롤 위치 설정
+    const setScrollPosition = useCallback((position) => {
+        if (scrollElement) {
+            scrollElement.scrollTo({ top: position, behavior });
+        }
+        else {
+            window.scrollTo({ top: position, behavior });
+        }
+    }, [scrollElement, behavior]);
+    // 현재 경로의 스크롤 위치 저장
+    const saveScrollPosition = useCallback(() => {
+        const path = location.pathname + location.search;
+        const position = getScrollPosition();
+        scrollPositions.set(path, position);
+    }, [location.pathname, location.search, getScrollPosition]);
+    // 스크롤 위치 복원
+    const restoreScrollPosition = useCallback(() => {
+        const path = location.pathname + location.search;
+        const savedPosition = scrollPositions.get(path);
+        if (savedPosition !== undefined) {
+            // 약간의 딜레이를 두고 복원 (DOM 렌더링 대기)
+            requestAnimationFrame(() => {
+                isRestoringRef.current = true;
+                setScrollPosition(savedPosition);
+                setTimeout(() => {
+                    isRestoringRef.current = false;
+                }, 100);
+            });
+            return true;
+        }
+        return false;
+    }, [location.pathname, location.search, setScrollPosition]);
+    // 상단으로 스크롤
+    const scrollToTop = useCallback(() => {
+        setScrollPosition(0);
+    }, [setScrollPosition]);
+    // 페이지 이동 감지 및 스크롤 처리
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const currentPath = location.pathname + location.search;
+        const prevPath = prevPathRef.current;
+        // 제외 경로인 경우 무시
+        if (excludePaths.some(path => location.pathname.startsWith(path))) {
+            prevPathRef.current = currentPath;
+            return;
+        }
+        // 이전 페이지 스크롤 위치 저장
+        if (prevPath && prevPath !== currentPath) {
+            const prevPosition = getScrollPosition();
+            scrollPositions.set(prevPath, prevPosition);
+        }
+        // 스크롤 복원 또는 상단 이동
+        const restored = restoreScrollPosition();
+        if (!restored && scrollToTopOnNewPage && prevPath !== currentPath) {
+            scrollToTop();
+        }
+        prevPathRef.current = currentPath;
+    }, [
+        enabled,
+        location.pathname,
+        location.search,
+        excludePaths,
+        getScrollPosition,
+        restoreScrollPosition,
+        scrollToTop,
+        scrollToTopOnNewPage,
+    ]);
+    // 페이지 이탈 시 스크롤 위치 저장
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const handleBeforeUnload = () => {
+            saveScrollPosition();
+        };
+        window.addEventListener('beforeunload', handleBeforeUnload);
+        return () => {
+            window.removeEventListener('beforeunload', handleBeforeUnload);
+        };
+    }, [enabled, saveScrollPosition]);
+    return {
+        saveScrollPosition,
+        restoreScrollPosition,
+        scrollToTop,
+        clearScrollPositions: () => scrollPositions.clear(),
+    };
+}
+/**
+ * useScrollToTop
+ * 페이지 이동 시 항상 상단으로 스크롤
+ *
+ * @example
+ * function App() {
+ *   useScrollToTop();
+ *   return <Routes>...</Routes>;
+ * }
+ */
+export function useScrollToTop(options = {}) {
+    const { behavior = 'auto' } = options;
+    const location = useLocation();
+    useEffect(() => {
+        window.scrollTo({ top: 0, behavior });
+    }, [location.pathname, behavior]);
+}
+export default useScrollRestoration;

package/dist/hooks/use-supabase-auth.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Supabase Auth Hooks
+ * Supabase 인증을 위한 전용 hooks
+ */
+import { Session } from '@supabase/supabase-js';
+import { User } from '../types';
+/**
+ * Supabase 로그인 Hook
+ */
+export declare function useSupabaseLogin(): {
+    login: (email: string, password: string) => Promise<{
+        session: Session;
+        user: User;
+    }>;
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Supabase 로그아웃 Hook
+ */
+export declare function useSupabaseLogout(): {
+    logout: () => Promise<void>;
+    isLoading: boolean;
+};
+/**
+ * Supabase 세션 Hook
+ * 현재 세션 상태를 반환하고 변경을 구독
+ */
+export declare function useSupabaseSession(): {
+    session: Session | null;
+    user: User | null;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+};
+/**
+ * Supabase Auth 상태 변경 구독 Hook
+ * Redux store와 동기화
+ */
+export declare function useSupabaseAuthSync(): void;
+/**
+ * 토큰 만료 전 선제 갱신 Hook
+ * KOMCA 스타일: 만료 5분 전 자동으로 토큰 갱신
+ * @param refreshBeforeMinutes 만료 전 갱신 시점 (분), 기본값 5분
+ */
+export declare function useTokenAutoRefresh(refreshBeforeMinutes?: number): {
+    isRefreshing: boolean;
+    lastRefreshed: Date | null;
+};
+//# sourceMappingURL=use-supabase-auth.d.ts.map

package/dist/hooks/use-supabase-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-supabase-auth.d.ts","sourceRoot":"","sources":["../../src/hooks/use-supabase-auth.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,OAAO,EAAmB,MAAM,uBAAuB,CAAC;AAIjE,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAehC;;GAEG;AACH,wBAAgB,gBAAgB;mBAIU,MAAM,YAAY,MAAM;;;;;;EA4CjE;AAED;;GAEG;AACH,wBAAgB,iBAAiB;;;EAiChC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB;;;;;EA6BjC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,SAwBlC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,oBAAoB,GAAE,MAAU;;;EA6FnE"}

package/dist/hooks/use-supabase-auth.js

@@ -0,0 +1,229 @@
+/**
+ * Supabase Auth Hooks
+ * Supabase 인증을 위한 전용 hooks
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { getSupabase } from '../network/supabase-client';
+import { getStore, setAccessToken, setUser, logout } from '../store/app-store';
+import { storage } from '../utils/storage';
+/**
+ * Supabase User를 앱 User 타입으로 변환
+ */
+function mapSupabaseUser(supabaseUser) {
+    return {
+        id: supabaseUser.id,
+        email: supabaseUser.email || '',
+        name: supabaseUser.user_metadata?.name || supabaseUser.email?.split('@')[0] || '',
+        role: supabaseUser.user_metadata?.role || 'user',
+        avatar: supabaseUser.user_metadata?.avatar_url,
+    };
+}
+/**
+ * Supabase 로그인 Hook
+ */
+export function useSupabaseLogin() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const login = useCallback(async (email, password) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const supabase = getSupabase();
+            const store = getStore();
+            const { data, error: authError } = await supabase.auth.signInWithPassword({
+                email,
+                password,
+            });
+            if (authError) {
+                throw new Error(authError.message);
+            }
+            if (!data.session || !data.user) {
+                throw new Error('로그인 응답이 올바르지 않습니다.');
+            }
+            const user = mapSupabaseUser(data.user);
+            // Redux store 업데이트
+            store.dispatch(setAccessToken(data.session.access_token));
+            store.dispatch(setUser(user));
+            // Storage에도 저장 (backup)
+            storage.setAccessToken(data.session.access_token);
+            storage.setUser(user);
+            console.log('[Supabase Login] 로그인 성공:', user.email);
+            return { session: data.session, user };
+        }
+        catch (err) {
+            const message = err.message || '로그인에 실패했습니다.';
+            setError(message);
+            console.error('[Supabase Login] 로그인 실패:', message);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    return { login, isLoading, error };
+}
+/**
+ * Supabase 로그아웃 Hook
+ */
+export function useSupabaseLogout() {
+    const [isLoading, setIsLoading] = useState(false);
+    const doLogout = useCallback(async () => {
+        setIsLoading(true);
+        try {
+            const supabase = getSupabase();
+            const store = getStore();
+            const { error } = await supabase.auth.signOut();
+            if (error) {
+                console.warn('[Supabase Logout] 서버 로그아웃 실패:', error.message);
+            }
+            // Redux store 초기화
+            store.dispatch(logout());
+            store.dispatch({ type: 'recentMenu/resetRecentMenu' });
+            // Storage 초기화
+            storage.clearAuth();
+            console.log('[Supabase Logout] 로그아웃 완료');
+        }
+        catch (err) {
+            console.error('[Supabase Logout] 로그아웃 실패:', err);
+            storage.clearAuth();
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    return { logout: doLogout, isLoading };
+}
+/**
+ * Supabase 세션 Hook
+ * 현재 세션 상태를 반환하고 변경을 구독
+ */
+export function useSupabaseSession() {
+    const [session, setSession] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    useEffect(() => {
+        const supabase = getSupabase();
+        // 현재 세션 가져오기
+        supabase.auth.getSession().then(({ data: { session } }) => {
+            setSession(session);
+            setIsLoading(false);
+        });
+        // 세션 변경 구독
+        const { data: { subscription } } = supabase.auth.onAuthStateChange((_event, session) => {
+            setSession(session);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return {
+        session,
+        user: session?.user ? mapSupabaseUser(session.user) : null,
+        isLoading,
+        isAuthenticated: !!session,
+    };
+}
+/**
+ * Supabase Auth 상태 변경 구독 Hook
+ * Redux store와 동기화
+ */
+export function useSupabaseAuthSync() {
+    useEffect(() => {
+        const supabase = getSupabase();
+        const store = getStore();
+        const { data: { subscription } } = supabase.auth.onAuthStateChange((event, session) => {
+            console.log('[Supabase Auth] 상태 변경:', event);
+            if (session) {
+                const user = mapSupabaseUser(session.user);
+                store.dispatch(setAccessToken(session.access_token));
+                store.dispatch(setUser(user));
+                storage.setAccessToken(session.access_token);
+                storage.setUser(user);
+            }
+            else {
+                store.dispatch(logout());
+                storage.clearAuth();
+            }
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+}
+/**
+ * 토큰 만료 전 선제 갱신 Hook
+ * KOMCA 스타일: 만료 5분 전 자동으로 토큰 갱신
+ * @param refreshBeforeMinutes 만료 전 갱신 시점 (분), 기본값 5분
+ */
+export function useTokenAutoRefresh(refreshBeforeMinutes = 5) {
+    const [isRefreshing, setIsRefreshing] = useState(false);
+    const [lastRefreshed, setLastRefreshed] = useState(null);
+    useEffect(() => {
+        const supabase = getSupabase();
+        const store = getStore();
+        let timeoutId = null;
+        const scheduleRefresh = async () => {
+            try {
+                const { data: { session } } = await supabase.auth.getSession();
+                if (!session?.expires_at) {
+                    return;
+                }
+                const expiresAt = session.expires_at * 1000; // seconds to ms
+                const refreshTime = expiresAt - (refreshBeforeMinutes * 60 * 1000);
+                const now = Date.now();
+                const timeout = refreshTime - now;
+                // 이미 만료 시점이 지났으면 즉시 갱신
+                if (timeout <= 0) {
+                    await performRefresh();
+                    return;
+                }
+                // 만료 전 갱신 스케줄링
+                console.log(`[Token Auto Refresh] ${Math.round(timeout / 1000 / 60)}분 후 토큰 갱신 예정`);
+                timeoutId = setTimeout(async () => {
+                    await performRefresh();
+                }, timeout);
+            }
+            catch (err) {
+                console.error('[Token Auto Refresh] 스케줄링 실패:', err);
+            }
+        };
+        const performRefresh = async () => {
+            if (isRefreshing)
+                return;
+            setIsRefreshing(true);
+            try {
+                const { data, error } = await supabase.auth.refreshSession();
+                if (error) {
+                    throw error;
+                }
+                if (data.session) {
+                    const user = mapSupabaseUser(data.session.user);
+                    store.dispatch(setAccessToken(data.session.access_token));
+                    store.dispatch(setUser(user));
+                    storage.setAccessToken(data.session.access_token);
+                    storage.setUser(user);
+                    setLastRefreshed(new Date());
+                    console.log('[Token Auto Refresh] 토큰 선제 갱신 완료');
+                    // 다음 갱신 스케줄링
+                    scheduleRefresh();
+                }
+            }
+            catch (err) {
+                console.error('[Token Auto Refresh] 토큰 갱신 실패:', err);
+            }
+            finally {
+                setIsRefreshing(false);
+            }
+        };
+        // 초기 스케줄링
+        scheduleRefresh();
+        // 세션 변경 시 재스케줄링
+        const { data: { subscription } } = supabase.auth.onAuthStateChange((event) => {
+            if (event === 'SIGNED_IN' || event === 'TOKEN_REFRESHED') {
+                scheduleRefresh();
+            }
+        });
+        return () => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            subscription.unsubscribe();
+        };
+    }, [refreshBeforeMinutes, isRefreshing]);
+    return { isRefreshing, lastRefreshed };
+}

package/dist/hooks/use-track-history.d.ts

@@ -1,5 +1,5 @@
 /**
- * Track History Hook - KOMCA 패턴
+ * Track History Hook
  * 라우팅 변경 감지 및 자동 탭(Recent Menu) 관리
  */
 import { RecentMenu } from '../types';
@@ -22,6 +22,7 @@ export declare function useTrackHistory(options: TrackHistoryOptions): {
 };
 /**
  * Recent Menu 상태 Hook
+ * useSelector를 사용하여 상태 변경 시 리렌더링 보장
  */
 export declare function useRecentMenuState<D = any>(): {
     list: RecentMenu[];

package/dist/hooks/use-track-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-track-history.d.ts","sourceRoot":"","sources":["../../src/hooks/use-track-history.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAItC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAGD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAkBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB;;EA0H3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,GAAG;;;;UAYX,CAAC,GAAG,SAAS;;EAG3C"}
+{"version":3,"file":"use-track-history.d.ts","sourceRoot":"","sources":["../../src/hooks/use-track-history.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAItC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAGD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAkBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB;;EA0H3D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,GAAG;;;;UA0BX,CAAC,GAAG,SAAS;;EAG3C"}