@ihabdevteam/core 0.134.0 → 0.135.0

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

@@ -1,6 +1,7 @@
 'use client';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { ensureTrainingDataLoaded } from '../utils/getTrainingData';
+import { getTodayKst } from '../utils/date';
 import { hasItems, resolveSelection, } from '../utils/dailySelectionUtils';
 // ─── 훅 ──────────────────────────────────────────────────────────────────────
 /**
@@ -29,6 +30,19 @@ export function useDailyTrainingSelection(userId) {
     // 가를 수가 없어** 설명 없는 빈 화면을 그리게 된다(실제로 그런 화면이 있다).
     // loaded 의 뜻을 바꾸면 지금 쓰는 곳이 깨지므로, 가를 수 있는 값을 따로 낸다.
     const [hasData, setHasData] = useState(false);
+    /* 오늘(KST) — 자정을 넘기면 바뀌어 아래 선택을 **새 날짜 시드로** 다시 계산하게 한다. 전에는 userId 만 봐서 화면을 열어 둔 채
+       자정을 넘기면 어제 시드의 세트가 '오늘' 로 보이는데 완료 기록에는 새 날짜가 찍혔다. */
+    const [오늘, set오늘] = useState(() => getTodayKst());
+    useEffect(() => {
+        const 다음자정까지 = () => {
+            const 지금 = Date.now();
+            const kst = new Date(지금 + 9 * 3600_000);
+            const 자정 = Date.UTC(kst.getUTCFullYear(), kst.getUTCMonth(), kst.getUTCDate() + 1) - 9 * 3600_000;
+            return Math.max(1000, 자정 - 지금 + 1000);
+        };
+        let t = setTimeout(function 넘김() { set오늘(getTodayKst()); t = setTimeout(넘김, 다음자정까지()); }, 다음자정까지());
+        return () => clearTimeout(t);
+    }, []);
     useEffect(() => {
         let cancelled = false;
         let timer;
@@ -90,7 +104,9 @@ export function useDailyTrainingSelection(userId) {
         tryFill();
         timer = setInterval(tryFill, 250);
         return () => { cancelled = true; stop(); };
-    }, [userId]);
+        // 오늘 은 날짜가 바뀌었다는 신호 — resolveSelection 이 안에서 오늘 날짜를 읽는다
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [userId, 오늘]);
     const getTrainingPerType = useCallback((typeKey) => {
         const src = showYesterday ? yesterdayRef.current : todayRef.current;
         const fallback = showYesterday ? todayRef.current : yesterdayRef.current;

package/dist/packages/core/src/hooks/useEditableList.d.ts

@@ -3,6 +3,12 @@
  *
  * @public
  */
+/**
+ * 같은 항목인가 — 같은 참조이거나, **둘 다 비지 않은 같은 id 를 가지면** 같다(빈 id 는 새로 만든 로컬 항목이라 견주지 않는다).
+ * 서버에서 목록을 다시 받으면 항목이 모두 새 객체가 되는데, 고른 항목·지울 항목을 참조로만 견주면 옛 참조가 아무것도
+ * 못 찾았다(수정 저장 → 재조회 → 같은 상세에서 '방문' 을 누르면 예정이 안 지워져 방문예정·방문완료 양쪽에 떴다).
+ */
+export declare function isSameEditableItem<T>(a: T, b: T): boolean;
 export declare function useEditableList<T>(emptyItem: T, initialList?: T[]): {
     list: T[];
     setList: import("react").Dispatch<import("react").SetStateAction<T[]>>;

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

@@ -5,6 +5,18 @@ import { useCallback, useEffect, useRef, useState } from 'react';
  *
  * @public
  */
+/**
+ * 같은 항목인가 — 같은 참조이거나, **둘 다 비지 않은 같은 id 를 가지면** 같다(빈 id 는 새로 만든 로컬 항목이라 견주지 않는다).
+ * 서버에서 목록을 다시 받으면 항목이 모두 새 객체가 되는데, 고른 항목·지울 항목을 참조로만 견주면 옛 참조가 아무것도
+ * 못 찾았다(수정 저장 → 재조회 → 같은 상세에서 '방문' 을 누르면 예정이 안 지워져 방문예정·방문완료 양쪽에 떴다).
+ */
+export function isSameEditableItem(a, b) {
+    if (a === b)
+        return true;
+    const ia = a?.id;
+    const ib = b?.id;
+    return ia != null && ia !== '' && ia === ib;
+}
 export function useEditableList(emptyItem, initialList = []) {
     const [list, setList] = useState(initialList);
     const [selected, setSelected] = useState(null);
@@ -42,7 +54,14 @@ export function useEditableList(emptyItem, initialList = []) {
             return;
         prevInitialRef.current = initialList;
         setList(initialList);
+        // 고른 항목도 새 목록의 같은 항목(id)으로 옮긴다 — 옛 참조로 남으면 지우기·수정 대상 찾기가 헛돈다
+        setSelected(prev => (prev == null ? prev : initialList.find(v => isSameEditableItem(v, prev)) ?? prev));
     }, [initialList]);
+    /* 편집 중이 아닐 때는 편집 폼을 고른 항목에 맞춘다 — 취소하거나(서버 거절로) 되돌려도 폼이 저장 안 된 값을 들고 있어,
+       상세 화면에 거절된 값이 보이고 다시 '수정하기' 를 누르면 그 값에서 시작했다. */
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    useEffect(() => { if (!isEditing && selected != null)
+        setEditForm({ ...selected }); }, [isEditing, selected]);
     const openDetail = useCallback((item) => {
         setSelected(item);
         setIsEditing(false);
@@ -56,7 +75,7 @@ export function useEditableList(emptyItem, initialList = []) {
         setIsEditing(false);
     }, []);
     const remove = useCallback((item) => {
-        setList(prev => prev.filter(v => v !== item));
+        setList(prev => prev.filter(v => !isSameEditableItem(v, item)));
         setSelected(null);
     }, []);
     return {

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

@@ -43,6 +43,10 @@ export function useTablePaging(rows, resetOn, opts) {
        대부분의 경우 빈 표가 된다 */
     const setPageSize = useCallback((v) => { setPageSizeRaw(v); setPage(1); }, []);
     const total = Math.max(1, Math.ceil(rows.length / Number(pageSize)));
+    /* 행이 줄어 범위를 넘으면 **상태도** 끝 쪽으로 맞춘다 — 보이는 쪽만 조이고 상태를 두면, 필터로 줄었다가 다시 늘 때 예전
+       5쪽으로 튀었다. 렌더 중에 맞춘다(위 resetOn 과 같은 꼴). */
+    if (page > total)
+        setPage(total);
     const 이쪽 = Math.min(page, total);
     const pageRows = useMemo(() => rows.slice((이쪽 - 1) * Number(pageSize), 이쪽 * Number(pageSize)), [rows, 이쪽, pageSize]);
     return {

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

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { useEditableList } from './useEditableList';
+import { useEditableList, isSameEditableItem } from './useEditableList';
 /**
  * @public
  */
@@ -24,7 +24,7 @@ export function useVisitHistory(initialHistory = []) {
         closeSubPopup?.();
     };
     const handleVisitEditSave = () => {
-        commitEdit(prev => prev.map(v => v === selectedVisit ? editVisitForm : v), editVisitForm);
+        commitEdit(prev => prev.map(v => (selectedVisit != null && isSameEditableItem(v, selectedVisit)) ? editVisitForm : v), editVisitForm);
     };
     /** 외부(스케줄 훅 등)에서 방문이력에 항목을 추가할 때 사용 */
     const addVisit = (item) => {

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

@@ -1,7 +1,7 @@
 'use client';
 import { useCallback, useMemo, useState } from 'react';
 import { today } from './useVisitHistory';
-import { useEditableList } from './useEditableList';
+import { useEditableList, isSameEditableItem } from './useEditableList';
 /**
  * 차례를 정하는 열쇠 — **가까운 것이 위**.
  *
@@ -48,17 +48,18 @@ initialSchedule = []) {
         closeSubPopup?.();
     };
     const handleScheduleEditSave = () => {
-        commitEdit(prev => sortByDate(prev.map(v => v === selectedSchedule ? editScheduleForm : v)), editScheduleForm);
+        commitEdit(prev => sortByDate(prev.map(v => (selectedSchedule != null && isSameEditableItem(v, selectedSchedule)) ? editScheduleForm : v)), editScheduleForm);
     };
     const handleScheduleDelete = useCallback((item) => {
         remove(item);
     }, [remove]);
     const handleScheduleToVisit = useCallback((item) => {
-        addVisit({ year: item.year, month: item.month, day: item.day, hour: item.hour, minute: item.minute, memo: item.memo });
+        // id 도 넘긴다 — 빠지면 그 방문을 이어서 수정할 때 합성 키로 넘어가 서버가 행을 못 찾았다
+        addVisit({ year: item.year, month: item.month, day: item.day, hour: item.hour, minute: item.minute, memo: item.memo, ...(item.id != null ? { id: item.id } : {}) });
         remove(item);
     }, [addVisit, remove]);
     const handleScheduleNoVisit = useCallback((item) => {
-        setScheduleList(prev => prev.filter(v => v !== item));
+        setScheduleList(prev => prev.filter(v => !isSameEditableItem(v, item)));
         setNoShowList(prev => [item, ...prev]);
         setSelectedSchedule(null);
     }, [setScheduleList, setSelectedSchedule]);

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

@@ -23,26 +23,35 @@ import { useState, useEffect, useMemo } from 'react';
 export const meaningKey = (word, homonum) => `${word}:${homonum ?? 1}`;
 // 세션 동안 유지되는 메모리 캐시 — 페이지를 오가도 재조회하지 않는다
 const memCache = new Map();
+/* 받아 봤는데 뜻이 없던 열쇠 — 다시 묻지 않는다. 전에는 뜻 없는 낱말이 캐시에 안 남아 표를 다시 정렬하거나 쪽을
+   넘길 때마다 같은 낱말을 또 조회했다. (조회가 실패한 것은 여기 넣지 않는다 — 다음에 다시 받는다.) */
+const noMeaning = new Set();
 export function useWordMeanings(rows, fetchMeanings) {
     /* 캐시는 모듈 스코프 Map 이라 갱신이 렌더에 자동 반영되지 않는다 — 조회가 끝나면 이 값을
        올려 아래 스냅샷을 다시 계산시킨다(캐시 히트만으로 리렌더가 연쇄되지 않도록 분리). */
     const [fetched, setFetched] = useState(0);
     // rows 는 매 렌더 새 배열이라 의존성으로 쓸 수 없다 — 조회 키만 뽑아 문자열로 비교한다
-    const wantedKey = rows.map(r => meaningKey(r.word, r.homonum)).join('|');
+    // 차례는 조회와 무관하다 — 정렬해 두어야 같은 낱말들을 다시 정렬만 해도 새 조회로 보지 않는다
+    const wantedKey = Array.from(new Set(rows.map(r => meaningKey(r.word, r.homonum)))).sort().join('|');
     useEffect(() => {
         const wanted = wantedKey ? wantedKey.split('|') : [];
-        const missing = wanted.filter(k => !memCache.has(k));
+        const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k));
         if (missing.length === 0)
             return; // 전부 캐시에 있음 — 네트워크·상태 갱신 불필요
         let cancelled = false;
         const words = Array.from(new Set(missing.map(k => k.slice(0, k.lastIndexOf(':')))));
         void fetchMeanings(words).then(got => {
-            if (cancelled || got.length === 0)
-                return;
+            /* 받은 것은 **취소됐어도 캐시에 담는다** — 쪽을 빨리 넘기면 앞 조회가 취소되며 받은 결과까지 버려, 돌아오면 또
+               조회했다. 화면 갱신(setFetched)만 취소된 쪽에서 건너뛴다. */
             for (const row of got) {
                 if (row.Meaning)
                     memCache.set(meaningKey(row.Word, row.Homonum ?? undefined), row.Meaning);
             }
+            for (const k of missing)
+                if (!memCache.has(k))
+                    noMeaning.add(k);
+            if (cancelled || got.length === 0)
+                return;
             setFetched(v => v + 1);
         }).catch(() => {
             // 조회 함수가 약속을 어기고 거절해도(망 끊김 등) 처리되지 않은 거절로 새지 않게 삼킨다 —

package/dist/packages/core/src/i18n/locales/en.json

@@ -742,7 +742,8 @@
             "descriptionPlaceholder": "Enter a description for this word table.",
             "duplicateName": "This name is already in use.",
             "nameRequired": "Please enter a table name.",
-            "autoFillHint": " (Press Tab or Space to autofill)"
+            "autoFillHint": " (Press Tab or Space to autofill)",
+            "copyName": "{{name}} (copy)"
         },
         "loadTable": {
             "title": "Load Saved Word Table",

package/dist/packages/core/src/i18n/locales/ko.json

@@ -740,7 +740,8 @@
             "descriptionPlaceholder": "이 단어표에 대한 설명을 입력하세요.",
             "duplicateName": "이미 사용 중인 이름입니다.",
             "nameRequired": "표 이름을 입력해 주세요.",
-            "autoFillHint": " (Tab 또는 space 입력시 자동 입력)"
+            "autoFillHint": " (Tab 또는 space 입력시 자동 입력)",
+            "copyName": "{{name}} (복사)"
         },
         "loadTable": {
             "title": "저장된 단어 표 불러오기",

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

@@ -104,6 +104,9 @@ export async function loadTrainingData() {
             catch (e) { }
             return;
         }
+        /* 다 읽은 뒤에 한꺼번에 넣는다 — 도중에 형식 오류로 멈추면 이미 넣은 것이 남은 채 재시도가 또 넣어, 부를 때마다 풀에
+           중복이 쌓였다(하루 선택이 중복 문항을 뽑고 기기마다 세트가 달라짐). */
+        const 받음 = { noise: [], short: [], long: [], order: [] };
         try {
             for (const key of Object.keys(map || {})) {
                 const groups = map[key] || [];
@@ -115,16 +118,16 @@ export async function loadTrainingData() {
                     // Preserve original group structure from allTrainingData.json
                     const groupObj = Object.assign({}, gr, { training_type: t, category_0: cat0, category_1: cat1 });
                     if (t === 'LISTEN_IN_NOISE') {
-                        NOISE_DATAS.push(groupObj);
+                        받음.noise.push(groupObj);
                     }
                     else if (t === 'SHORT_STORY') {
-                        SHORT_STORIES.push(groupObj);
+                        받음.short.push(groupObj);
                     }
                     else if (t === 'LONG_STORY') {
-                        LONG_STORIES.push(groupObj);
+                        받음.long.push(groupObj);
                     }
                     else if (t === 'ORDERING_SENTENCE') {
-                        ORDER_SETS.push(groupObj);
+                        받음.order.push(groupObj);
                     }
                 }
             }
@@ -142,6 +145,10 @@ export async function loadTrainingData() {
             catch { /* SSR 등 */ }
             return;
         }
+        NOISE_DATAS.push(...받음.noise);
+        SHORT_STORIES.push(...받음.short);
+        LONG_STORIES.push(...받음.long);
+        ORDER_SETS.push(...받음.order);
         try {
             window.dispatchEvent(new Event('speechear.data.updated'));
         }

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

@@ -60,13 +60,16 @@ export async function checkImageExists(word, homonum) {
         return false;
     // 타임아웃 없으면 HEAD 요청 하나가 응답 없이 걸릴 때 이 확인을 기다리는
     // 검색 버튼(이미지 있음 필터)이 영구 비활성화된다
+    /* **확인이 안 된 것은 캐시하지 않는다.** 망 끊김·타임아웃·5xx 까지 '이미지 없음' 으로 영구 저장해, 한 번 끊긴 단어는 망이
+       돌아와도 '이미지 있음' 필터에서 계속 빠졌다(ttsConfig.checkAudioExists 와 같게). 있음(2xx)·없음(4xx)만 담는다. */
     const p = fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(8000) })
-        .then(res => res.ok)
-        .catch(() => false)
+        .then(res => (res.status >= 500 ? null : res.ok), () => null)
         .then(ok => {
+        inflight.delete(k);
+        if (ok === null)
+            return false;
         map[k] = ok;
         scheduleSave();
-        inflight.delete(k);
         return ok;
     });
     inflight.set(k, p);

package/dist/packages/core/src/utils/wordTrainingRuntime.d.ts

@@ -9,7 +9,7 @@ export declare function generateRuntimeItems(typeKey: WordTrainingTypeKey, opts?
  * 공통 조합을 백그라운드에서 사전 계산해 결과 캐시를 미리 채운다.
  * 이후 동일 조합으로 generateRuntimeItems 호출 시 즉시(<5ms) 반환.
  * fire-and-forget — 완료 여부에 관계없이 UI 블로킹 없음.
- * UI가 실제로 쓰는 difficulty(cap.difficulty→'count', 그 외 null)만 예열한다.
+ * UI가 실제로 쓰는 열쇠(count 5 · 난이도 'random'/'count' · 필터 기본값)로 예열한다.
  * (과거 대립종류 cho/jung/jong 예열은 UI 미사용이고 정작 count는 누락돼 첫 생성이 느렸음)
  */
 export declare function precomputeCommonCombinations(excludeNoImage: boolean): Promise<void>;

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

@@ -599,11 +599,14 @@ async function _generateRuntimeItems(typeKey, opts = {}) {
  * 공통 조합을 백그라운드에서 사전 계산해 결과 캐시를 미리 채운다.
  * 이후 동일 조합으로 generateRuntimeItems 호출 시 즉시(<5ms) 반환.
  * fire-and-forget — 완료 여부에 관계없이 UI 블로킹 없음.
- * UI가 실제로 쓰는 difficulty(cap.difficulty→'count', 그 외 null)만 예열한다.
+ * UI가 실제로 쓰는 열쇠(count 5 · 난이도 'random'/'count' · 필터 기본값)로 예열한다.
  * (과거 대립종류 cho/jung/jong 예열은 UI 미사용이고 정작 count는 누락돼 첫 생성이 느렸음)
  */
 export async function precomputeCommonCombinations(excludeNoImage) {
-    const difficulties = [null, 'count'];
+    /* **화면이 실제로 부르는 열쇠와 똑같이** 예열한다. 전에는 count:10 · 난이도 null/'count' 로 돌았는데 화면
+       (useWordTrainingDataGeneration)은 count:5 · 필터 기본 난이도 'random'(음소를 고르면 'count')으로 불러 캐시 열쇠가
+       달랐다 — 예열 계산을 전부 버리고 첫 생성이 다시 계산했다. */
+    const difficulties = ['random', 'count'];
     const types = Object.keys(CAPABILITY);
     let tick = 0;
     for (const diff of difficulties) {
@@ -611,9 +614,13 @@ export async function precomputeCommonCombinations(excludeNoImage) {
             const cap = CAPABILITY[t];
             generateRuntimeItems(t, {
                 difficulty: cap.difficulty ? diff : null,
-                choseong: null,
-                count: 10,
+                contrastCount: 1,
+                composition: null,
+                count: 5,
                 excludeNoImage,
+                sameStructureOnly: true,
+                phonemeView: 'char',
+                grade: null,
             }).catch(() => { });
             // 6 타입마다 마이크로태스크 양보 → 메인 스레드 프레임 블로킹 방지
             if (++tick % 6 === 0)

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

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

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

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