@ihabdevteam/core 0.141.0 → 0.143.0

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

@@ -50,6 +50,11 @@ export declare function matchesChoseongSearch(text: string, search: string): boo
  * 검색어에 종성 겹자모·비한글 등 위 종류가 아닌 문자가 있으면 일반 부분 문자열로 폴백한다.
  */
 export declare function matchesWordQuery(word: string, query: string): boolean;
+/**
+ * @internal matchesWordQuery 의 검색어 쪽 준비(NFC·글자 분류)를 **한 번만** 해 두고 낱말마다 부르는 판별기.
+ * 목록 전체(2.3만 낱말)를 거를 때 낱말마다 검색어를 다시 펼치고 분류해, 키를 누를 때마다 14–36ms 걸렸다.
+ */
+export declare function makeWordQueryMatcher(query: string): (word: string) => boolean;
 /** @public 복합 종성 index → 구성 자모 배열 (예: 9(ㄺ) → ['ㄹ','ㄱ']) */
 export declare const JONG_DECOMPOSE: Record<number, string[]>;
 /** @public 단어가 특정 자모(음소)를 어디든 (초성/종성/복합종성) 포함하는지 */

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

@@ -100,6 +100,9 @@ export function isAllChoseong(search) {
 export function matchesChoseongSearch(text, search) {
     if (!search)
         return true;
+    /* 맥·PDF 에서 붙여넣은 글은 조각 한글(NFD, '가' = ᄀ+ᅡ)이라 완성 음절과 한 글자도 같지 않다 — 둘 다 NFC 로 맞춘다. */
+    text = text.normalize('NFC');
+    search = search.normalize('NFC');
     if (isAllChoseong(search))
         return toChoseong(text).includes(search);
     return text.toLowerCase().includes(search.toLowerCase());
@@ -112,55 +115,69 @@ export function matchesChoseongSearch(text, search) {
  * 검색어에 종성 겹자모·비한글 등 위 종류가 아닌 문자가 있으면 일반 부분 문자열로 폴백한다.
  */
 export function matchesWordQuery(word, query) {
+    return makeWordQueryMatcher(query)(word);
+}
+/**
+ * @internal matchesWordQuery 의 검색어 쪽 준비(NFC·글자 분류)를 **한 번만** 해 두고 낱말마다 부르는 판별기.
+ * 목록 전체(2.3만 낱말)를 거를 때 낱말마다 검색어를 다시 펼치고 분류해, 키를 누를 때마다 14–36ms 걸렸다.
+ */
+export function makeWordQueryMatcher(query) {
     if (!query)
-        return true;
+        return () => true;
+    // 조각 한글(NFD) 붙여넣기는 '기타 문자' 로 분류돼 부분 문자열 비교로 새고 0건이 됐다 — 둘 다 NFC 로
+    query = query.normalize('NFC');
     const q = [...query];
     const isCho = (ch) => CHOSEONG.includes(ch);
     const isJung = (ch) => JUNGSEONG.includes(ch);
     // 각 글자 분류: 'cho'(자음/초성) | 'jung'(모음/중성) | 'syl'(완성 음절) | 'other'(그 외)
     const kinds = q.map(ch => (isCho(ch) ? 'cho' : isJung(ch) ? 'jung' : parseSyllable(ch) ? 'syl' : 'other'));
+    const qSyl = q.map(ch => parseSyllable(ch));
     // 영문은 대소문자를 가리지 않는다 — 옆 matchesChoseongSearch 와 같게('apple' 로 'Apple' 을 찾는다)
-    if (kinds.includes('other'))
-        return word.toLowerCase().includes(query.toLowerCase());
-    const w = [...word];
-    for (let i = 0; i + q.length <= w.length; i++) {
-        let ok = true;
-        for (let j = 0; j < q.length; j++) {
-            const wc = w[i + j];
-            const k = kinds[j];
-            if (k === 'cho') {
-                if (firstChoseongOf(wc) !== q[j]) {
-                    ok = false;
-                    break;
-                }
-            }
-            else if (k === 'jung') {
-                const s = parseSyllable(wc);
-                if (!s || JUNGSEONG[s.jung] !== q[j]) {
-                    ok = false;
-                    break;
+    if (kinds.includes('other')) {
+        const lower = query.toLowerCase();
+        return (word) => word.normalize('NFC').toLowerCase().includes(lower);
+    }
+    return (word) => {
+        const w = [...word.normalize('NFC')];
+        for (let i = 0; i + q.length <= w.length; i++) {
+            let ok = true;
+            for (let j = 0; j < q.length; j++) {
+                const wc = w[i + j];
+                const k = kinds[j];
+                if (k === 'cho') {
+                    if (firstChoseongOf(wc) !== q[j]) {
+                        ok = false;
+                        break;
+                    }
                 }
-            }
-            else { // 'syl' — 완성 음절
-                const qs = parseSyllable(q[j]);
-                if (qs && qs.jong === 0) {
-                    // 받침 없는 글자는 초성+중성만 비교(받침 무관): '수' → 수·술·숙·순 …
-                    const ws = parseSyllable(wc);
-                    if (!ws || ws.cho !== qs.cho || ws.jung !== qs.jung) {
+                else if (k === 'jung') {
+                    const s = parseSyllable(wc);
+                    if (!s || JUNGSEONG[s.jung] !== q[j]) {
                         ok = false;
                         break;
                     }
                 }
-                else if (wc !== q[j]) {
-                    ok = false;
-                    break;
-                } // 받침 있으면 정확 일치
+                else { // 'syl' — 완성 음절
+                    const qs = qSyl[j];
+                    if (qs && qs.jong === 0) {
+                        // 받침 없는 글자는 초성+중성만 비교(받침 무관): '수' → 수·술·숙·순 …
+                        const ws = parseSyllable(wc);
+                        if (!ws || ws.cho !== qs.cho || ws.jung !== qs.jung) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    else if (wc !== q[j]) {
+                        ok = false;
+                        break;
+                    } // 받침 있으면 정확 일치
+                }
             }
+            if (ok)
+                return true;
         }
-        if (ok)
-            return true;
-    }
-    return false;
+        return false;
+    };
 }
 // 복합 종성 자모 분해 (예: ㄺ → ㄹ+ㄱ)
 /** @public 복합 종성 index → 구성 자모 배열 (예: 9(ㄺ) → ['ㄹ','ㄱ']) */
@@ -418,6 +435,8 @@ function matchesPatternAtom(ch, atom) {
  * 0건이 된다(조용히 무관 처리하지 않는다 — 제약이 무시된 채 결과가 나오는 오해를 막기 위해).
  */
 export function matchesSyllablePattern(word, pattern) {
+    word = word.normalize('NFC');
+    pattern = pattern.normalize('NFC'); // 조각 한글(NFD) 붙여넣기
     const atoms = pattern.split(',').flatMap(chunk => parseChunkToAtoms(chunk.trim()));
     if (atoms.length === 0)
         return true;
@@ -497,7 +516,8 @@ function isSearchAtomChar(ch) {
  * @returns 유효하면 `{ ok: true }`, 아니면 `{ ok: false }`(호출부가 안내 문구를 표시).
  */
 export function validateSyllableSearchInput(input) {
-    const trimmed = input.trim();
+    // 조각 한글(NFD) 붙여넣기가 '해석할 수 없는 글자' 로 입력 오류 안내를 띄웠다
+    const trimmed = input.normalize('NFC').trim();
     if (!trimmed)
         return { ok: true };
     for (const raw of trimmed.split(',')) {
@@ -643,16 +663,22 @@ export function countPhonemeDiff(a, b) {
  * @public
  */
 export function searchAndRankWords(items, query) {
-    const q = query.trim();
+    const q = query.normalize('NFC').trim(); // 조각 한글(NFD) 붙여넣기
     if (!q || !/[^\s,_]/.test(q))
         return items;
     if (isSyllablePattern(q))
         return items.filter(w => matchesSyllablePattern(w.word, q));
-    const hit = items.filter(w => matchesWordQuery(w.word, q) || matchesWordQuery(w.pronunciation ?? '', q));
+    // 검색어 준비는 한 번 — 낱말마다 다시 하면 키 한 번에 2.3만 번 펼치고 분류했다
+    const m = makeWordQueryMatcher(q);
     const headLen = [...q].length;
-    const startsWith = (s) => !!s && matchesWordQuery(s.slice(0, headLen), q);
-    return hit
-        .map(w => ({ w, rank: (startsWith(w.word) || startsWith(w.pronunciation ?? '')) ? 0 : 1 }))
-        .sort((a, b) => a.rank - b.rank)
-        .map(s => s.w);
+    const startsWith = (s) => !!s && m(s.normalize('NFC').slice(0, headLen));
+    // 순위는 두 갈래로 나눠 잇는다(안정 정렬과 같은 순서)
+    const 앞 = [];
+    const 뒤 = [];
+    for (const w of items) {
+        if (!(m(w.word) || m(w.pronunciation ?? '')))
+            continue;
+        (startsWith(w.word) || startsWith(w.pronunciation ?? '') ? 앞 : 뒤).push(w);
+    }
+    return 앞.concat(뒤);
 }

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

@@ -484,9 +484,26 @@ preferAsTarget) {
         for (let p = 0; p < target.syls.length; p++) {
             const key = makeKey(target.syls, p);
             const candidates = groups.get(key) ?? [];
+            const ts = target.syls[p];
             for (const candidate of candidates) {
                 if (candidate.entry.word === target.entry.word)
                     continue;
+                /* 같은 묶음은 p 자리 밖이 모두 같다 — p 자리에서 정확히 한 성분만 달라야 최소대립쌍이다. 1음절 낱말은 전부 한 묶음이라
+                   묶음이 커서, 쌍 문자열·발음 분해(analyzeMinimalPair) 전에 먼저 거른다(음소를 고를 때마다 110–320ms 걸렸다). */
+                {
+                    const cs = candidate.syls[p];
+                    let d = 0;
+                    if (ts.초성 !== cs.초성)
+                        d++;
+                    if (ts.모음 !== cs.모음)
+                        d++;
+                    if (ts.종성 !== cs.종성)
+                        d++;
+                    if ((ts.활음 ?? '') !== (cs.활음 ?? ''))
+                        d++;
+                    if (d !== 1)
+                        continue;
+                }
                 const dedupKey = target.entry.word < candidate.entry.word
                     ? `${target.entry.word}|${candidate.entry.word}`
                     : `${candidate.entry.word}|${target.entry.word}`;

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

@@ -1,3 +1,13 @@
 /** 글자 둘을 한국어 차례로 견준다 */
 export declare function 한글순(a: string, b: string): number;
+/**
+ * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 나머지는 글자 속 숫자까지 수로.**
+ *
+ * 표의 칸은 무엇이든 올 수 있어서 늘 글자로 견주면 **숫자 칸이 망가진다**
+ * (`10` 이 `9` 앞에 선다). 그래서 둘 다 온전한 숫자(수, 또는 숫자만 든 글자)면 숫자로 견주고,
+ * 그 밖에는 한국어 차례로 견주되 글자 안의 숫자는 수로 읽는다(`회차 9` 가 `회차 10` 앞).
+ *
+ * 비어 있는 값(`null`·`undefined`)은 빈 글자로 본다 — 부르는 쪽이 이미
+ * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
+ */
 export declare function 칸순(a: unknown, b: unknown): number;

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

@@ -22,16 +22,6 @@ const 콜레이터 = (() => {
 export function 한글순(a, b) {
     return 콜레이터().compare(a, b);
 }
-/**
- * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 나머지는 글자로.**
- *
- * 표의 칸은 무엇이든 올 수 있어서 늘 글자로 견주면 **숫자 칸이 망가진다**
- * (`10` 이 `9` 앞에 선다). 그래서 둘 다 진짜 숫자일 때만 숫자로 견주고,
- * 그 밖에는 한국어 차례를 쓴다.
- *
- * 비어 있는 값(`null`·`undefined`)은 빈 글자로 본다 — 부르는 쪽이 이미
- * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
- */
 const 숫자글자 = /^-?\d+(\.\d+)?$/;
 /* 칸의 글자 비교는 **안의 숫자도 수로** 본다 — 숫자 칸끼리는 수로, 섞인 칸은 글자로 견주면 '9'<'10'(수)·'10'<'10분'(글자)·
    '10분'<'9'(글자) 로 돌고 돌아, 같은 행을 들어온 차례만 바꿔도 정렬 결과가 달랐다. 수를 수로 읽는 콜레이터는
@@ -44,6 +34,16 @@ const 칸콜레이터 = (() => {
         return 것;
     };
 })();
+/**
+ * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 나머지는 글자 속 숫자까지 수로.**
+ *
+ * 표의 칸은 무엇이든 올 수 있어서 늘 글자로 견주면 **숫자 칸이 망가진다**
+ * (`10` 이 `9` 앞에 선다). 그래서 둘 다 온전한 숫자(수, 또는 숫자만 든 글자)면 숫자로 견주고,
+ * 그 밖에는 한국어 차례로 견주되 글자 안의 숫자는 수로 읽는다(`회차 9` 가 `회차 10` 앞).
+ *
+ * 비어 있는 값(`null`·`undefined`)은 빈 글자로 본다 — 부르는 쪽이 이미
+ * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
+ */
 export function 칸순(a, b) {
     /* NaN 은 숫자가 아닌 것으로 — a - b 가 NaN 이면 정렬 비교가 어긋나 줄이 뒤섞였다. 글자로 온 숫자('10'·'9')도
        둘 다 온전한 숫자면 숫자로 견준다(전에는 '10' 이 '9' 앞에 섰다). */
@@ -51,5 +51,10 @@ export function 칸순(a, b) {
     const na = 수(a), nb = 수(b);
     if (na !== null && nb !== null)
         return na - nb;
-    return 칸콜레이터().compare(a == null ? '' : String(a), b == null ? '' : String(b));
+    const sa = a == null ? '' : String(a), sb = b == null ? '' : String(b);
+    /* 소수점·음수가 든 글자('12.5%'·'-10 dB')는 수로 읽는 콜레이터가 틀린다 — 점 뒤를 따로 떼어 '12.5' 가 '12.25' 뒤에,
+       빼기표를 버려 '-5' 가 '-10' 뒤에 섰다. 그런 칸은 한국어 글자 차례로 둔다. 선행 0 도 수로 읽으면 'A007'='A7' 이 되어 글자로. */
+    if (/\d\.\d|-\d|(^|\D)0\d/.test(sa) || /\d\.\d|-\d|(^|\D)0\d/.test(sb))
+        return 한글순(sa, sb);
+    return 칸콜레이터().compare(sa, sb);
 }

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

@@ -0,0 +1,5 @@
+/**
+ * `ms` 뒤 끊기는 AbortSignal. `AbortSignal.timeout` 은 Safari 16 부터라 iOS/iPadOS 15 이하(치료실 구형 iPad)에서는
+ * 없어 fetch 를 부르기도 전에 TypeError 로 거절됐다 — 없으면 AbortController + setTimeout 으로 만든다.
+ */
+export declare function timeoutSignal(ms: number): AbortSignal;

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

@@ -0,0 +1,12 @@
+/**
+ * `ms` 뒤 끊기는 AbortSignal. `AbortSignal.timeout` 은 Safari 16 부터라 iOS/iPadOS 15 이하(치료실 구형 iPad)에서는
+ * 없어 fetch 를 부르기도 전에 TypeError 로 거절됐다 — 없으면 AbortController + setTimeout 으로 만든다.
+ */
+export function timeoutSignal(ms) {
+    const native = AbortSignal.timeout;
+    if (typeof native === 'function')
+        return native.call(AbortSignal, ms);
+    const c = new AbortController();
+    setTimeout(() => c.abort(), ms);
+    return c.signal;
+}

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

@@ -20,6 +20,7 @@
  *
  * @public
  */
+import { timeoutSignal } from './timeoutSignal';
 const GLOBAL_KEY = '__ihab_core_tts_config__';
 /**
  * TTS URL 리졸버를 전역으로 설정합니다.
@@ -84,7 +85,7 @@ export async function checkAudioExists(word) {
             audioExistsCache.delete(url);
         return false;
     };
-    const promise = fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(8000) })
+    const promise = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) })
         .then(res => (res.status >= 500 ? 확인안됨() : res.ok), 확인안됨);
     audioExistsCache.set(url, promise);
     return promise;

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

@@ -141,15 +141,17 @@ position) {
                 answersByPos.set(i, [pw]);
         }
         for (const [pos, answers] of answersByPos) {
-            const maskedSlots = new Set(selParts.map(p => pos + ':' + p));
+            // 가릴 성분은 대립 자리(pos)의 것뿐 — 낱말·자리·성분마다 'i:part' 문자열을 만들어 Set 에서 찾던 것을 불리언으로(열쇠 모양은 같다)
+            const mC = selParts.includes('cho'), mJ = selParts.includes('jung'), mG = selParts.includes('jong');
             // 마스킹 템플릿은 '발음' 분해 기준 (대립 자리 외 발음이 전부 같은 단어끼리 묶음)
             const templateOf = (d) => {
                 let key = '';
                 for (let i = 0; i < L; i++) {
                     const s = d[i];
-                    for (const part of ['cho', 'jung', 'jong']) {
-                        key += (maskedSlots.has(i + ':' + part) ? '*' : s[part]) + '.';
-                    }
+                    if (i === pos)
+                        key += (mC ? '*' : s.cho) + '.' + (mJ ? '*' : s.jung) + '.' + (mG ? '*' : s.jong) + '.';
+                    else
+                        key += s.cho + '.' + s.jung + '.' + s.jong + '.';
                 }
                 return key;
             };

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

@@ -9,7 +9,7 @@
  * 재료 고르기는 성능이 전부고(캐시·부분 셔플·병렬 이미지 확인), 문제 만들기는 훈련 타입마다
  * 규칙이 다르다. 한쪽을 볼 때 다른 쪽이 끼어들지 않게 갈라 둔다.
  */
-import { getImageExistsCached, getImageExistenceStats } from './imageConfig';
+import { getImageExistenceStats, getImageOkWordSet } from './imageConfig';
 import { getWordPool } from './wordPool';
 import { shuffle } from './array';
 import { getPairIndex } from './wordPairIndex';
@@ -143,11 +143,12 @@ export function filterByCachedImage(words) {
         return all;
     }
     // prewarm 완료 → 이미지 확인된 단어만 허용
+    // 낱말마다 '${w}_1' 열쇠를 만들어 찾던 것을 캐시 판마다 한 번 만든 집합으로(칩 한 번에 유형 수만큼 돌았다)
+    const ok = getImageOkWordSet();
     const result = new Set();
-    for (const w of words) {
-        if (getImageExistsCached(w) === true)
+    for (const w of words)
+        if (ok.has(w))
             result.add(w);
-    }
     return result;
 }
 // ─── buildUsablePool 캐시 ──────────────────────────────────────────────────
@@ -440,7 +441,15 @@ async function _buildUsablePool(opts) {
         else if (useRandomPool) {
             // 'random' 또는 null(difficulty:false 타입): 음운론적 제약은 없지만,
             // 정답과 오답의 음절수는 같아야 한다(단어 길이만으로 정답을 짐작하지 못하도록) — 본 단어와 다른 단어 + 음절수(글자수) 동일
-            usable = distractorPool.filter(other => other !== w.w && other.length === w.w.length && pronOfWord(other) !== wPron);
+            const 쓸수있음 = (other) => other !== w.w && other.length === w.w.length && pronOfWord(other) !== wPron;
+            /* 셈(fullCount — 가능 단어 수 안내)은 '오답이 하나라도 있나' 만 본다. 2.2만 후보마다 600개를 끝까지 걸러 칩 한 번에
+               300ms 넘게 멈췄다. 셈은 결과 개수만 쓰고(countUsableWords → pool.length) 오답 목록은 쓰지 않는다. */
+            if (opts.fullCount) {
+                const one = distractorPool.find(쓸수있음);
+                usable = one === undefined ? [] : [one];
+            }
+            else
+                usable = distractorPool.filter(쓸수있음);
         }
         else {
             // cho/jung/jong: 발음 기반 pairIndex에서 해당 종류 대립쌍 조회(공용 엔진). 구조 필터는 후처리에서 일괄.

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

@@ -39,7 +39,7 @@ export { copyText } from './utils/clipboard';
 export { formatPhone, normalizeDate, dateToDb, formatTimeHM, formatCount } from './utils/format';
 export { configureTrainingCategories, getTopicTypes, getTrainingTypes } from './utils/categories';
 export type { TopicType, TopicSubType, TrainingType, TrainingCategoryConfig } from './utils/categories';
-export { formatYmd, formatRelativeTime, getTodayKst, toKstYmd, toKstHm, formatDateKo, formatDateLongKo, formatDatetimeKo, formatDateLocale, formatDateLongLocale } from './utils/date';
+export { formatYmd, formatRelativeTime, getTodayKst, getTodayKstDate, kstStartOfDay, parseLocalYmd, toKstYmd, toKstHm, formatDateKo, formatDateLongKo, formatDatetimeKo, formatDateLocale, formatDateLongLocale } from './utils/date';
 export type { FormatYmdOptions } from './utils/date';
 export { getSavedTheme, applyTheme, initTheme } from './utils/theme';
 export type { ThemeMode } from './utils/theme';

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

@@ -27,7 +27,7 @@ export { toStorageName, toBase64UrlSafe, officialSoundPath } from './utils/encod
 export { copyText } from './utils/clipboard';
 export { formatPhone, normalizeDate, dateToDb, formatTimeHM, formatCount } from './utils/format';
 export { configureTrainingCategories, getTopicTypes, getTrainingTypes } from './utils/categories';
-export { formatYmd, formatRelativeTime, getTodayKst, toKstYmd, toKstHm, formatDateKo, formatDateLongKo, formatDatetimeKo, formatDateLocale, formatDateLongLocale } from './utils/date';
+export { formatYmd, formatRelativeTime, getTodayKst, getTodayKstDate, kstStartOfDay, parseLocalYmd, toKstYmd, toKstHm, formatDateKo, formatDateLongKo, formatDatetimeKo, formatDateLocale, formatDateLongLocale } from './utils/date';
 export { getSavedTheme, applyTheme, initTheme } from './utils/theme';
 export { getSavedFontScale, applyFontScale, initFontScale } from './utils/fontScale';
 export { classifyPairDifficulty, firstChoseongOf, toChoseong, isAllChoseong, matchesChoseongSearch } from './utils/koreanSyllable';

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

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

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

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