@ihabdevteam/core 0.342.0 → 0.344.0

package/dist/packages/core/src/hooks/useWordMeanings.js

@@ -34,18 +34,41 @@ export function useWordMeanings(rows, fetchMeanings) {
     /* 캐시는 모듈 스코프 Map 이라 갱신이 렌더에 자동 반영되지 않는다 — 조회가 끝나면 이 값을
        올려 아래 스냅샷을 다시 계산시킨다(캐시 히트만으로 리렌더가 연쇄되지 않도록 분리). */
     const [fetched, setFetched] = useState(0);
+    const [retry, setRetry] = useState(0);
     // rows 는 매 렌더 새 배열이라 의존성으로 쓸 수 없다 — 조회 키만 뽑아 문자열로 비교한다
     // 차례는 조회와 무관하다 — 정렬해 두어야 같은 낱말들을 다시 정렬만 해도 새 조회로 보지 않는다
-    const wantedKey = Array.from(new Set(rows.map(r => meaningKey(r.word, r.homonum)))).sort().join('|');
+    const wantedKey = JSON.stringify(Array.from(new Set(rows.map(r => meaningKey(r.word, r.homonum)))).sort());
     useEffect(() => {
-        const wanted = wantedKey ? wantedKey.split('|') : [];
+        const wanted = JSON.parse(wantedKey);
         const now = Date.now();
         const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k) && !(now - (emptyAt.get(k) ?? -Infinity) < EMPTY_GRACE_MS));
-        if (missing.length === 0)
-            return; // 전부 캐시에 있음 — 네트워크·상태 갱신 불필요
         let cancelled = false;
+        let retryTimer = null;
+        let retryDue = Infinity;
+        const scheduleRetry = (delay = EMPTY_GRACE_MS) => {
+            if (cancelled)
+                return;
+            const due = Date.now() + delay;
+            if (due >= retryDue)
+                return;
+            if (retryTimer !== null)
+                clearTimeout(retryTimer);
+            retryDue = due;
+            retryTimer = setTimeout(() => setRetry(n => n + 1), delay);
+        };
+        // 유예 중 화면을 닫았다 다시 열어도 만료 시 재조회한다.
+        for (const k of wanted) {
+            if (memCache.has(k) || noMeaning.has(k))
+                continue;
+            const at = emptyAt.get(k);
+            if (at != null && now - at < EMPTY_GRACE_MS)
+                scheduleRetry(Math.max(0, EMPTY_GRACE_MS - (now - at)));
+        }
+        if (missing.length === 0)
+            return () => { cancelled = true; if (retryTimer !== null)
+                clearTimeout(retryTimer); };
         const words = Array.from(new Set(missing.map(k => k.slice(0, k.lastIndexOf(':')))));
-        void fetchMeanings(words).then(got => {
+        void Promise.resolve().then(() => fetchMeanings(words)).then(got => {
             /* 받은 것은 **취소됐어도 캐시에 담는다** — 쪽을 빨리 넘기면 앞 조회가 취소되며 받은 결과까지 버려, 돌아오면 또
                조회했다. 화면 갱신(setFetched)만 취소된 쪽에서 건너뛴다. */
             for (const row of got) {
@@ -63,18 +86,22 @@ export function useWordMeanings(rows, fetchMeanings) {
                 const t = Date.now();
                 for (const k of missing)
                     emptyAt.set(k, t);
+                // 화면을 그대로 보고 있어도 유예가 끝나면 다시 묻는다.
+                scheduleRetry();
             }
             if (cancelled || got.length === 0)
                 return;
             setFetched(v => v + 1);
         }).catch(() => {
             // 조회 함수가 약속을 어기고 거절해도(망 끊김 등) 처리되지 않은 거절로 새지 않게 삼킨다 —
-            // 뜻은 있으면 좋은 것이라 빈 결과와 같게 다룬다. 캐시에 안 넣었으니 다음에 다시 받는다.
+            // 뜻은 있으면 좋은 것이라 빈 결과와 같게 다룬다. 같은 화면에서도 잠시 뒤 다시 묻는다.
+            scheduleRetry();
         });
-        return () => { cancelled = true; };
-    }, [wantedKey, fetchMeanings]);
+        return () => { cancelled = true; if (retryTimer !== null)
+            clearTimeout(retryTimer); };
+    }, [wantedKey, fetchMeanings, retry]);
     return useMemo(() => {
-        const wanted = wantedKey ? wantedKey.split('|') : [];
+        const wanted = JSON.parse(wantedKey);
         const out = new Map();
         for (const k of wanted) {
             const v = memCache.get(k);

package/dist/packages/core/src/hooks/useWordTrainingFilter.js

@@ -257,12 +257,16 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
             if (cancelled)
                 return;
             setViable(v);
-            // 빈 결과 = 단어 풀 미로드 상태. 준비됨으로 보지 않아 저장된 선택을 성급히 해제하지 않는다.
-            if (v.cho.size + v.jung.size + v.jong.size > 0)
-                setViableReady(true);
+            // 빈 결과 = 단어 풀 미로드 상태. 앞서 한 번 준비됐더라도 갱신 중엔 다시
+            // 준비 안 됨으로 돌려 저장된 음소 선택을 빈 집합으로 검증하지 않는다.
+            setViableReady(v.cho.size + v.jung.size + v.jong.size > 0);
         })
-            .catch(() => { if (!cancelled)
-            setViable({ cho: new Set(), jung: new Set(), jong: new Set(), syllable: new Set() }); });
+            .catch(() => {
+            if (!cancelled) {
+                setViable({ cho: new Set(), jung: new Set(), jong: new Set(), syllable: new Set() });
+                setViableReady(false);
+            }
+        });
         return () => { cancelled = true; };
     }, [caps.choseong, difficulty, excludeNoImage, poolVersion]);
     // 현재 필터 조건으로 가능한 정답 단어 수 계산 (버튼 선택이 바뀔 때마다)

package/dist/packages/core/src/utils/getTrainingData.js

@@ -108,8 +108,12 @@ export async function loadTrainingData() {
            중복이 쌓였다(하루 선택이 중복 문항을 뽑고 기기마다 세트가 달라짐). */
         const received = { noise: [], short: [], long: [], order: [] };
         try {
-            for (const key of Object.keys(map || {})) {
-                const groups = map[key] || [];
+            if (typeof map !== 'object' || Array.isArray(map))
+                throw new Error('Invalid training data map');
+            for (const key of Object.keys(map)) {
+                const groups = map[key];
+                if (!Array.isArray(groups))
+                    throw new Error('Invalid training data group');
                 for (const g of groups) {
                     // 한 행이 null·글자면 건너뛴다 — 그 한 행의 TypeError 로 자료 전체를 버리고 매번 같은 실패를 되풀이했다
                     if (!g || typeof g !== 'object')
@@ -154,6 +158,9 @@ export async function loadTrainingData() {
         ORDER_SETS.push(...received.order);
         // 다 채운 뒤 _loaded 를 먼저 세운다 — 'updated' 를 받은 쪽이 isTrainingDataLoaded() 로 확인하면 아직 false 였다
         _loaded = true;
+        // 데이터가 오기 전에 계산한 빈 세트가 같은 날짜·개수의 캐시로 남을 수 있다.
+        // 어제 세트도 옛 풀을 재사용하지 않도록 캐시 전체를 무효화한다.
+        _cachedSelection = null;
         try {
             computeDailySelection();
         }

package/dist/packages/core/src/utils/imageConfig.js

@@ -27,7 +27,14 @@ function ensureLoaded() {
         const v = raw ? JSON.parse(raw) : null;
         /* 객체가 아닌 JSON(null·"x"·42·배열)이 들어 있으면 `k in map`·Object.values 가 부를 때마다 던지고 memMap 이 null 로 남아
            매번 다시 파싱했다 — 확장 프로그램·손으로 고친 값이라도 캐시 비우기 전까지 이미지 확인·훈련 생성이 막혔다. */
-        memMap = v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+        const valid = {};
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            for (const [key, value] of Object.entries(v)) {
+                if (typeof value === 'boolean')
+                    valid[key] = value;
+            }
+        }
+        memMap = valid;
     }
     catch {
         memMap = {};
@@ -36,7 +43,7 @@ function ensureLoaded() {
 }
 let savePending = null;
 function scheduleSave() {
-    if (savePending)
+    if (savePending !== null)
         return;
     savePending = setTimeout(() => {
         savePending = null;
@@ -51,31 +58,42 @@ function scheduleSave() {
 function keyOf(word, homonum) {
     return `${word}_${homonum ?? 1}`;
 }
-/**
- * @public
- * 단어 이미지 존재 여부 확인 — localStorage 캐시 우선, 없으면 HEAD 요청 후 캐시 저장.
- * 한 번 확인된 단어는 영구 캐싱되어 다음 접속 시에도 즉시 반환.
- */
-export async function checkImageExists(word, homonum) {
+async function probeImageExists(word, homonum, force = false) {
     const map = ensureLoaded();
     const k = keyOf(word, homonum);
-    if (k in map)
+    if (!force && k in map)
         return map[k];
-    if (inflight.has(k))
+    if (!force && inflight.has(k))
         return inflight.get(k);
     const resolver = getImageResolver();
     if (!resolver)
         return false;
-    const url = resolver(word, homonum);
+    let url;
+    try {
+        url = resolver(word, homonum);
+    }
+    catch {
+        return false;
+    }
     if (!url)
         return false;
     // 타임아웃 없으면 HEAD 요청 하나가 응답 없이 걸릴 때 이 확인을 기다리는
     // 검색 버튼(이미지 있음 필터)이 영구 비활성화된다
-    /* **확인이 안 된 것은 캐시하지 않는다.** 망 끊김·타임아웃·5xx 까지 '이미지 없음' 으로 영구 저장해, 한 번 끊긴 단어는 망이
-       돌아와도 '이미지 있음' 필터에서 계속 빠졌다(ttsConfig.checkAudioExists 와 같게). 있음(2xx)·없음(4xx)만 담는다. */
-    const p = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) })
-        .then(res => (res.status >= 500 ? null : res.ok), () => null)
+    /* **확인이 안 된 것은 캐시하지 않는다.** 망 끊김·타임아웃·권한 오류·5xx 는 이미지가 없다는 증거가 아니다.
+       있음(2xx)과 명시적 없음(404·410)만 담는다. */
+    let request;
+    try {
+        request = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) });
+    }
+    catch {
+        return false;
+    }
+    const p = request
+        .then(res => (res.ok ? true : res.status === 404 || res.status === 410 ? false : null), () => null)
         .then(ok => {
+        // 강제 재확인이 앞 요청을 대체했거나 캐시를 비웠다면 늦은 응답으로 새 값을 덮지 않는다.
+        if (inflight.get(k) !== p)
+            return ok ?? false;
         inflight.delete(k);
         if (ok === null)
             return false;
@@ -87,6 +105,14 @@ export async function checkImageExists(word, homonum) {
     inflight.set(k, p);
     return p;
 }
+/**
+ * @public
+ * 단어 이미지 존재 여부 확인 — localStorage 캐시 우선, 없으면 HEAD 요청 후 캐시 저장.
+ * 한 번 확인된 단어는 영구 캐싱되어 다음 접속 시에도 즉시 반환.
+ */
+export async function checkImageExists(word, homonum) {
+    return probeImageExists(word, homonum);
+}
 /** @public 단어 이미지 존재 여부 동기 조회 (캐시에 있을 때만). 없으면 undefined. */
 export function getImageExistsCached(word, homonum) {
     const map = ensureLoaded();
@@ -107,7 +133,8 @@ export async function prewarmImageCache(words, options = {}) {
     let done = 0;
     if (todo.length > 0) {
         let idx = 0;
-        const workers = Array.from({ length: Math.min(concurrency, todo.length) }, async () => {
+        const workerCount = Math.min(todo.length, Math.max(1, Number.isFinite(concurrency) ? Math.floor(concurrency) : 16));
+        const workers = Array.from({ length: workerCount }, async () => {
             while (idx < todo.length) {
                 const i = idx++;
                 const w = todo[i];
@@ -118,7 +145,7 @@ export async function prewarmImageCache(words, options = {}) {
                     continue;
                 }
                 try {
-                    await checkImageExists(w);
+                    await probeImageExists(w, undefined, force);
                 }
                 catch { }
                 done++;
@@ -170,6 +197,9 @@ export function getImageOkWordSet() {
  */
 export function bulkSetImageExistence(entries) {
     const map = ensureLoaded();
+    // 일괄 주입이 정본이다. 앞서 시작한 HEAD가 늦게 끝나 새 값을 덮지 못하게 한다.
+    for (const k of Object.keys(entries))
+        inflight.delete(k);
     Object.assign(map, entries);
     cacheVersion++;
     try {
@@ -181,7 +211,12 @@ export function bulkSetImageExistence(entries) {
 }
 /** @public 캐시 초기화 (이미지 데이터 변경 시 호출) */
 export function clearImageExistenceCache() {
+    if (savePending !== null) {
+        clearTimeout(savePending);
+        savePending = null;
+    }
     memMap = {};
+    inflight.clear();
     cacheVersion++;
     try {
         if (typeof localStorage !== 'undefined')

package/dist/packages/core/src/utils/prefetchChunk.js

@@ -27,9 +27,16 @@
  */
 export function prefetchChunk(...loads) {
     let cancelled = false;
-    const load = () => { if (!cancelled)
-        for (const load of loads)
-            void load().catch(() => { }); };
+    const load = () => {
+        if (cancelled)
+            return;
+        for (const load of loads) {
+            try {
+                void load().catch(() => { });
+            }
+            catch { /* 미리 받기 실패는 화면 전환 때 다시 시도한다 */ }
+        }
+    };
     const idle = globalThis.requestIdleCallback;
     if (idle) {
         const id = idle(load, { timeout: 2000 });

package/dist/packages/core/src/utils/speak.js

@@ -15,40 +15,64 @@ export function speak(text, { onEnd, rate = 0.9 } = {}) {
     }
     const synth = window.speechSynthesis;
     clearPendingWait();
+    let finished = false;
+    const finish = () => {
+        if (finished)
+            return;
+        finished = true;
+        try {
+            onEnd?.();
+        }
+        catch (e) { }
+    };
+    // 새 말을 위한 목소리 목록을 기다리는 동안에도 이전 발화는 바로 멈춘다.
+    try {
+        synth.cancel();
+    }
+    catch (e) {
+        finish();
+        return;
+    }
     const doSpeak = () => {
         clearPendingWait();
-        synth.cancel();
-        const u = new SpeechSynthesisUtterance(text);
-        const voices = synth.getVoices();
-        const ko = voices.find(v => v.lang.startsWith('ko'));
-        if (ko)
-            u.voice = ko;
-        u.rate = rate;
-        u.onend = onEnd
-            ? function (_ev) {
-                try {
-                    onEnd();
-                }
-                catch (e) { }
-            }
-            : null;
-        // 합성이 실패하면 end 없이 error 만 온다 — 끝난 것으로 알린다(안 그러면 onEnd 를 기다리는 쪽이 멈춘 채)
-        u.onerror = onEnd
-            ? function () {
-                try {
-                    onEnd();
-                }
-                catch (e) { }
-            }
-            : null;
-        synth.speak(u);
+        try {
+            synth.cancel();
+            const u = new SpeechSynthesisUtterance(text);
+            const voices = synth.getVoices();
+            const ko = voices.find(v => v.lang.startsWith('ko'));
+            if (ko)
+                u.voice = ko;
+            u.rate = rate;
+            u.onend = onEnd ? finish : null;
+            // 합성이 실패하면 end 없이 error 만 온다 — 끝난 것으로 알린다(안 그러면 onEnd 를 기다리는 쪽이 멈춘 채)
+            u.onerror = onEnd ? finish : null;
+            synth.speak(u);
+        }
+        catch (e) {
+            finish();
+        }
     };
-    if (synth.getVoices().length > 0) {
+    let voices;
+    try {
+        voices = synth.getVoices();
+    }
+    catch (e) {
+        finish();
+        return;
+    }
+    if (voices.length > 0) {
         doSpeak();
         return;
     }
     const timer = setTimeout(doSpeak, VOICE_WAIT_MS);
-    synth.addEventListener('voiceschanged', doSpeak, { once: true });
+    try {
+        synth.addEventListener('voiceschanged', doSpeak, { once: true });
+    }
+    catch (e) {
+        clearTimeout(timer);
+        finish();
+        return;
+    }
     pendingWait = {
         clear: () => {
             clearTimeout(timer);

package/dist/packages/core/src/utils/ttsConfig.js

@@ -76,7 +76,7 @@ export async function checkAudioExists(word) {
         return audioExistsCache.get(url);
     // 타임아웃 없으면 HEAD 요청 하나가 응답 없이 걸릴 때 이 확인을 기다리는
     // 검색 버튼(음성 있음 필터)이 영구 비활성화된다
-    // 서버가 답을 준 경우(2xx/4xx)만 캐시에 남긴다. 네트워크 실패·타임아웃·5xx 까지 캐시하면
+    // 성공(2xx)과 명시적 부재(404·410)만 캐시에 남긴다. 권한 오류·네트워크 실패·타임아웃·5xx 까지 캐시하면
     // 한 번의 통신 끊김·서버 장애가 그 단어를 세션 내내 '음성 없음'으로 고정해, '음성 있음' 필터에서
     // 통째로 빠진다. 실패는 지워서 다음 호출이 다시 물어보게 한다 — 단 **이 요청이 담은 칸일 때만**:
     // clearAudioExistsCache() 뒤 새로 담긴 확인을 늦게 끝난 옛 요청이 지우면 같은 주소를 또 묻는다.
@@ -85,8 +85,15 @@ export async function checkAudioExists(word) {
             audioExistsCache.delete(url);
         return false;
     };
-    const promise = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) })
-        .then(res => (res.status >= 500 ? onUnconfirmed() : res.ok), onUnconfirmed);
+    let request;
+    try {
+        request = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) });
+    }
+    catch {
+        return false;
+    }
+    const promise = request
+        .then(res => (res.ok ? true : res.status === 404 || res.status === 410 ? false : onUnconfirmed()), onUnconfirmed);
     audioExistsCache.set(url, promise);
     return promise;
 }

package/dist/packages/core/src/utils/wordPairIndex.js

@@ -19,6 +19,20 @@ const LS_PAIR_INDEX = 'word_pair_index_v2';
 const LS_PAIR_INDEX_SIG = 'word_pair_index_sig_v2';
 let memIndex = null;
 let memSig = null;
+function isPairIndex(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    for (const entry of Object.values(value)) {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            return false;
+        const parts = entry;
+        for (const kind of ['cho', 'jung', 'jong']) {
+            if (!Array.isArray(parts[kind]) || !parts[kind].every((word) => typeof word === 'string'))
+                return false;
+        }
+    }
+    return true;
+}
 function loadFromLocalStorage() {
     try {
         if (typeof localStorage === 'undefined')
@@ -27,7 +41,8 @@ function loadFromLocalStorage() {
         const sig = localStorage.getItem(LS_PAIR_INDEX_SIG);
         if (!raw || !sig)
             return null;
-        return { index: JSON.parse(raw), sig };
+        const index = JSON.parse(raw);
+        return isPairIndex(index) ? { index, sig } : null;
     }
     catch {
         return null;

package/dist/packages/core/src/version.d.ts

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export declare const CORE_VERSION = "0.342.0";
+export declare const CORE_VERSION = "0.344.0";

package/dist/packages/core/src/version.js

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export const CORE_VERSION = '0.342.0';
+export const CORE_VERSION = '0.344.0';