@ihabdevteam/core 0.149.0 → 0.151.0

package/dist/packages/core/src/components/Word/WordSearchResultBlock.d.ts

@@ -10,9 +10,15 @@ export interface WordSearchResultGroup {
 /** @public */
 export interface WordSearchResultBlockProps {
     titleIcon?: string;
+    /**
+     * 검색 결과 수 — 제목 "총 N개" 에 쓴다. **검색 화면이라는 표시이기도 하다**: 이것도 `searchQuery` 도 주지 않으면
+     * 저장된 목록을 보여 주는 것으로 보고(공유 열람) 받은 순서를 기본 정렬로 둔다('받은 순서' 선택지가 생긴다).
+     */
     resultCount?: number;
     resultUnit?: string;
+    /** 검색어 — 한 낱말이면 '시작 우선' 을 기본 정렬로 쓴다 */
     searchQuery?: string;
+    /** 보일 항목. 검색어·결과 수 없이 이것만 주면 받은 순서 그대로가 기본이다 */
     items: WordSearchResultItem[];
     groups?: WordSearchResultGroup[];
     selected?: string[];

package/dist/packages/core/src/components/Word/WordSearchResultBlock.js

@@ -37,31 +37,38 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
     const rawQuery = (searchQuery ?? '').trim();
     const q = /^[^,[\]\s]+$/.test(rawQuery) ? rawQuery : '';
     const hasQuery = q.length > 0;
+    /* **검색어도 결과 수도 없이 items 만 받으면 검색 결과가 아니라 저장된 목록을 보여 주는 것**(말귀 공유 링크 열람 —
+       치료사가 표에서 끌어 옮긴 순서가 저장돼 있다). 그때는 받은 순서를 기본으로 둔다 — 가나다로 다시 늘어서
+       표의 칸 순서가 사라졌다. 검색 화면들은 결과 수(resultCount)를 늘 주므로 지금처럼 가나다 · 시작 우선이다. */
+    const 열람 = searchQuery === undefined && resultCount === undefined;
+    const 기본정렬 = hasQuery ? 'match' : 열람 ? 'original' : 'ganada';
     // 첫 렌더에 이미 검색어가 있어도 '시작 우선'으로 시작한다 — 아래 조정은 검색어 유무가 **바뀔 때**만 돌아서,
     // 초깃값을 'ganada' 로 고정하면 검색어를 들고 마운트한 화면은 가나다순에 머물렀다.
-    const [sortKey, setSortKey] = useState(() => (hasQuery ? 'match' : 'ganada'));
+    const [sortKey, setSortKey] = useState(() => 기본정렬);
     const [pageSizeStr, setPageSizeStr] = useState('50');
     const [page, setPage] = useState(1);
     // 검색어 유무가 바뀌면 그에 맞는 기본 정렬로 되돌린다(렌더 중 상태 조정).
     const [prevHasQuery, setPrevHasQuery] = useState(hasQuery);
     if (prevHasQuery !== hasQuery) {
         setPrevHasQuery(hasQuery);
-        setSortKey(hasQuery ? 'match' : 'ganada');
+        setSortKey(기본정렬);
     }
-    const effectiveSortKey = (sortKey === 'match' && !hasQuery) ? 'ganada' : sortKey;
+    const effectiveSortKey = (sortKey === 'match' && !hasQuery) || (sortKey === 'original' && !열람) ? 기본정렬 : sortKey;
     const sortOptions = useMemo(() => [
         ...(hasQuery ? [{ value: 'match', label: t('wordSearch.sort.match', { defaultValue: '시작 우선' }) }] : []),
+        ...(열람 ? [{ value: 'original', label: t('wordSearch.sort.original', { defaultValue: '받은 순서' }) }] : []),
         { value: 'ganada', label: t('wordSearch.sort.ganada', { defaultValue: '가나다순 ↑' }) },
         { value: 'ganada_desc', label: t('wordSearch.sort.ganadaDesc', { defaultValue: '가나다순 ↓' }) },
         { value: 'syllable', label: t('wordSearch.sort.syllable', { defaultValue: '음절 수 ↑' }) },
         { value: 'syllable_desc', label: t('wordSearch.sort.syllableDesc', { defaultValue: '음절 수 ↓' }) },
         { value: 'grade', label: t('wordSearch.sort.grade', { defaultValue: '등급순 ↑' }) },
         { value: 'grade_desc', label: t('wordSearch.sort.gradeDesc', { defaultValue: '등급순 ↓' }) },
-    ], [t, hasQuery]);
+    ], [t, hasQuery, 열람]);
     const pageSizeOptions = useMemo(() => ['10', '25', '50', '100'].map(v => ({
         value: v, label: t('wordSearch.pageSize', { count: Number(v), defaultValue: `${v}개씩 보기` }),
     })), [t]);
-    const firstWord = (it) => it.words[0];
+    /* 저장소에서 온 항목에 words 가 빠져 있을 수 있다({ id }) — 이 파일은 낱말을 늘 `?? []` 로 읽는다 */
+    const firstWord = (it) => it.words?.[0];
     /* '시작 우선' 순위는 검색어가 바뀔 때 판별기를 한 번 만들고 항목마다 한 번만 센다 — 비교할 때마다 검색어를 다시 펼치고
        localeCompare 를 불러 결과가 바뀔 때 23k 개에 38ms 걸렸다. */
     const 시작순위 = useMemo(() => {
@@ -71,7 +78,7 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
         return (it) => {
             let r = memo.get(it);
             if (r === undefined) {
-                r = m((it.words[0]?.label ?? '').slice(0, qLen)) ? 0 : 1;
+                r = m((it.words?.[0]?.label ?? '').slice(0, qLen)) ? 0 : 1;
                 memo.set(it, r);
             }
             return r;
@@ -81,7 +88,12 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
     const sortCompare = useCallback((a, b) => {
         const label = (it) => firstWord(it)?.label ?? '';
         const syll = (it) => firstWord(it)?.syllables ?? [...label(it)].length;
-        const grade = (it) => { const n = parseInt(firstWord(it)?.grade ?? '', 10); return Number.isFinite(n) ? n : 999; };
+        /* 등급은 **칸의 낱말 중 낮은(숫자가 작은) 등급** — 대립쌍의 첫 낱말만 보면 둘째가 1등급인 쌍이 3·3 쌍 뒤로 갔다.
+           엔진 기본 정렬(searchPairs 결과)과 같은 셈이라, 등급순을 고르는 순간 차례가 뒤바뀌지 않는다. 등급 없는 낱말은 맨 뒤. */
+        const grade = (it) => (it.words ?? []).reduce((min, w) => {
+            const n = parseInt(w.grade ?? '', 10);
+            return Number.isFinite(n) && n < min ? n : min;
+        }, 999);
         switch (effectiveSortKey) {
             // 시작 우선 — 검색어로 시작하는 단어를 위로. 앞 q 글자만 잘라 매칭하면 "첫 음절부터 일치"만
             // 남는다(초성 검색도 동일: 'ㄴ' → '나무'가 위). 동순위는 가나다.
@@ -94,6 +106,7 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
             case 'syllable_desc': return syll(b) - syll(a) || label(a).localeCompare(label(b), 'ko');
             case 'grade': return grade(a) - grade(b) || label(a).localeCompare(label(b), 'ko');
             case 'grade_desc': return grade(b) - grade(a) || label(a).localeCompare(label(b), 'ko');
+            // 받은 순서 — Array.prototype.sort 는 안정 정렬이라 0 이면 받은 차례가 남는다
             default: return 0;
         }
     }, [effectiveSortKey, 시작순위]);
@@ -149,17 +162,17 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
                                 const isSelected = selected.includes(item.id);
                                 return (_jsx("div", { onMouseEnter: e => {
                                         openHover(e.currentTarget);
-                                        setHoverWords(item.words);
-                                    }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: item.words.map(w => w.label), subLabel: item.words.map(w => w.subLabel).filter(Boolean).length > 0
-                                            ? item.words.map(w => w.subLabel)
+                                        setHoverWords(item.words ?? []);
+                                    }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: (item.words ?? []).map(w => w.label), subLabel: (item.words ?? []).some(w => w.subLabel)
+                                            ? (item.words ?? []).map(w => w.subLabel)
                                             : undefined, selected: isSelected, onClick: () => handleClick(item.id), minWidth: 200 }) }, item.id));
                             }) }) }, group.label)))) : (_jsx("div", { className: "word-search-result-block__items", children: pagedItems.map((item) => {
                             const isSelected = selected.includes(item.id);
                             return (_jsx("div", { onMouseEnter: e => {
                                     openHover(e.currentTarget);
-                                    setHoverWords(item.words);
-                                }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: item.words.map(w => w.label), subLabel: item.words.map(w => w.subLabel).filter(Boolean).length > 0
-                                        ? item.words.map(w => w.subLabel)
+                                    setHoverWords(item.words ?? []);
+                                }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: (item.words ?? []).map(w => w.label), subLabel: (item.words ?? []).some(w => w.subLabel)
+                                        ? (item.words ?? []).map(w => w.subLabel)
                                         : undefined, selected: isSelected, onClick: () => handleClick(item.id), minWidth: 200 }) }, item.id));
                         }) })), hoverWords && hoverAnchorRect && (_jsx(WordImageTooltip, { words: hoverWords, anchorRect: hoverAnchorRect }))] }), totalPages > 1 && (_jsx("div", { className: "word-search-result-block__pagination-bottom", children: _jsx(Pagination, { page: pageClamped, totalPages: totalPages, onChange: setPage }) })), (onClearSelection || onPrint) && (_jsxs("div", { className: "word-search-result-block__actions", children: [onClearSelection && (_jsx(Button, { htmlType: "button", size: "56", type: "bar", label: t('common.resetSelection', '선택 초기화'), selected: false, disabled: selected.length === 0, onClick: selected.length === 0 ? undefined : onClearSelection })), onPrint && (_jsx("div", { onClick: selected.length === 0 ? onPrintEmpty : undefined, children: _jsx(Button, { htmlType: "button", size: "56", type: "bar", variant: "main", label: t('wordTable.title', '단어 표 만들기'), disabled: selected.length === 0, onClick: selected.length === 0 ? undefined : onPrint }) }))] }))] }));
 }

package/dist/packages/core/src/components/Word/WordTableBlock.js

@@ -12,7 +12,7 @@ import Popup from '../Popup/Popup';
 import WordTable, { WORD_TABLE_PAPER } from '../WordTable';
 import { chunkItems } from '../wordTableLayout';
 import TableFilterPanel from './TableFilterPanel';
-import { buildItemsPerPageSection, buildPageNumberSection, PAGE_NUM_POSITION_VALUE, parsePageNumberPosition } from './wordTableSettings';
+import { buildItemsPerPageSection, buildPageNumberSection, PAGE_NUM_POSITION_VALUE, parsePageNumberPosition, itemsPerPageFromChoice } from './wordTableSettings';
 import Toast from '../Toast';
 import { useToastState } from '../../hooks/useToastState';
 import { getImageResolver, checkImageExists } from '../../utils/imageConfig';
@@ -20,7 +20,7 @@ import { formatYmd, getTodayKst } from '../../utils/date';
 import { getSavedTables } from '../../utils/savedWordTables';
 import { devWarnOnce } from '../../utils/devWarn';
 import { useWordTablePrint } from './useWordTablePrint';
-import { CELL_COUNTS, ITEMS_PER_PAGE_OPTIONS } from './wordTableBlockTypes';
+import { CELL_COUNTS } from './wordTableBlockTypes';
 // ── 컴포넌트 ───────────────────────────────────────────────
 /** @public */
 /** 편집 칸의 낱말 → 저장 항목의 낱말. 편집 칸에서 보이던 구어체 발음·등급·품사·유형을 그대로 옮긴다. */
@@ -102,19 +102,15 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
     if (onAddItem && !isEditable && !showCellCount) {
         devWarnOnce('word-table-block-add-without-cell-count', '[WordTableBlock] 표시 모드에서 onAddItem 은 showCellCount 와 함께 줘야 "추가하기" 칸이 생긴다.');
     }
-    // display 모드에서 칸 수 조절용 상태 (showCellCount일 때만 사용)
-    const [displayCellCount, setDisplayCellCount] = useState(() => Math.max(items?.length ?? 1, 1));
-    /* eslint-disable react-hooks/set-state-in-effect */
-    useEffect(() => {
-        if (!isEditable)
-            setDisplayCellCount(prev => Math.max(prev, items?.length ?? 1));
-    }, [items?.length, isEditable]);
-    /* eslint-enable react-hooks/set-state-in-effect */
+    /* display 모드에서 칸 수 조절용 상태 (showCellCount일 때만 사용) — **고른 값만** 든다. 보이는 칸 수는
+       max(고른 값, 항목 수) 로 그때그때 낸다. 전에는 고를 때와 항목이 늘 때 max 로 굳혀, 6칸을 골라 둔 표에 8개를
+       담았다 3개로 줄여도 8칸이 남았다. 처음 값은 처음 항목 수 — 고르기 전에 하나를 빼도 표가 한 칸 줄어 흔들리지 않게. */
+    const [chosenCellCount, setChosenCellCount] = useState(() => Math.max(items?.length ?? 1, 1));
     // 레이아웃 칸 수
     const count = isEditable
         ? cellCount
         : showCellCount
-            ? Math.max(displayCellCount, items?.length ?? 1)
+            ? Math.max(chosenCellCount, items?.length ?? 1, 1)
             : Math.max(items?.length ?? 0, 1);
     const { width, height } = WORD_TABLE_PAPER[orientation];
     // 페이지 분할 — 편집/칸수조절(showCellCount) 모드에서는 적용하지 않고, 완성된 표시 모드에서만 적용
@@ -128,7 +124,7 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
     const isPaginated = !!pages && pages.length > 1;
     const hasPairs = isEditable
         ? visibleCells.some(c => c !== null && c.length > 1)
-        : (items ?? []).some(item => item.words.length > 1);
+        : (items ?? []).some(item => (item.words ?? []).length > 1);
     // PDF로 저장할 때 OS가 제안하는 기본 파일명. 저장된 표 이름이 있으면 그대로, 없으면 "오늘 날짜 + 단어표/대립쌍표"
     const printFileName = tableName?.trim()
         || `${formatYmd(getTodayKst())} ${hasPairs ? t('wordTable.printFileNamePair', '대립쌍표') : t('wordTable.printFileNameSingle', '단어표')}`;
@@ -164,7 +160,7 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
     };
     const hasColloquial = isEditable
         ? visibleCells.some(c => c?.some(e => !!e.colloquialPronunciation))
-        : (items ?? []).some(item => item.words.some(w => !!w.colloquialLabel));
+        : (items ?? []).some(item => (item.words ?? []).some(w => !!w.colloquialLabel));
     // 표에 실제로 이미지가 있는지 — resolver(word)는 존재 여부와 무관하게 항상 URL을 만들어 반환하므로
     // 그 truthiness만으로는 판정할 수 없다(항상 true가 되어 이미지 없는 표에서도 '이미지' 토글이
     // 활성화되는 문제가 있었다). checkImageExists로 실제 HEAD 요청(+캐시) 확인을 거친다.
@@ -176,7 +172,7 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
             return [];
         return isEditable
             ? cells.slice(0, cellCount).flatMap(c => (c ?? []).map(e => [e.word, e.homonum]))
-            : (items ?? []).flatMap(item => item.words.map(w => [w.label, w.homonum]));
+            : (items ?? []).flatMap(item => (item.words ?? []).map(w => [w.label, w.homonum]));
     }, [isEditable, cells, cellCount, items]);
     /* 실제로 파일이 있는지는 물어봐야 안다(HEAD 요청 + 캐시). 그 답만 상태로 든다.
        `imagePairs` 가 비면 물어볼 것도 없으므로 아래 유도에서 곧바로 false 가 된다. */
@@ -209,15 +205,13 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
         if (sectionLabel === t('wordTable.filter.columns', '칸 수')) {
             if (isEditable)
                 handleCellCountChange(parseInt(value));
-            // 항목 수보다 적게는 못 줄인다(그리드는 항목 수만큼 그린다) — 고른 값을 그대로 담으면 켜진 칸 수와 보이는 표가 달랐다
+            /* 고른 값을 그대로 기억한다 — 항목 수보다 적게 골라도 보이는 칸 수(count)는 max 로 항목 수를 지키고,
+               항목이 줄면 고른 값으로 돌아간다 */
             else
-                setDisplayCellCount(Math.max(parseInt(value), items?.length ?? 1));
+                setChosenCellCount(parseInt(value));
         }
         else if (sectionLabel === t(hasPairs ? 'wordTable.filter.itemsPerPagePair' : 'wordTable.filter.itemsPerPageWord')) {
-            /* 목록에 없는 개수(= 그때의 '전체' 칸)를 고르면 **전체** 로 기억한다 — 숫자로 담으면 항목이 늘었을 때 고른 값('10개')이
-               선택지([20, 8, 4, 2, 1])에 없어 켜진 칸이 없는데 표는 10개씩 나뉘었다. */
-            const n = parseInt(value);
-            setItemsPerPageSetting(ITEMS_PER_PAGE_OPTIONS.includes(n) ? n : Number.POSITIVE_INFINITY);
+            setItemsPerPageSetting(itemsPerPageFromChoice(parseInt(value), itemCount));
         }
         else if (sectionLabel === t('wordTable.filter.pageNumber', '페이지 번호')) {
             setPageNumberPosition(parsePageNumberPosition(value));
@@ -230,6 +224,12 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
             words: c.map(항목낱말),
         })))
         : items ?? [];
+    /* 저장한 뒤에는 **숨은 칸(cellCount 뒤)을 비운다** — 2칸으로 줄여 저장한 표를 4칸으로 늘리면 저장본에 없던
+       셋째·넷째 낱말이 다시 떠, 저장한 것과 화면이 달랐다. 저장하지 않고 줄였다 늘리는 동안에는 그대로 들고 있는다. */
+    const 숨은칸비우기 = () => {
+        if (isEditable)
+            setCells(prev => (prev.length > cellCount ? prev.slice(0, cellCount) : prev));
+    };
     const handleSave = (asNew = false) => {
         setSaveAsNew(asNew);
         // 인라인 이름·설명 모드: 팝업 없이 화면의 이름·설명으로 즉시 저장(덮어쓰기). 빈 값은 제안(placeholder)으로 대체.
@@ -240,11 +240,13 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
             if (savedLower)
                 setSavedNames(prev => prev.includes(savedLower) ? prev : [...prev, savedLower]);
             onSaveComplete(trimmedName, saveItems, trimmedDescription || undefined, asNew);
+            숨은칸비우기();
             return;
         }
         // saveOnly: 이름 입력 팝업 없이 바로 저장(이름은 상위에서 처리)
         if (saveOnly && onSaveComplete) {
             onSaveComplete('', saveItems, undefined, asNew);
+            숨은칸비우기();
             return;
         }
         if (onSaveComplete) {
@@ -267,6 +269,7 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
         if (!saveAsTrimmed || saveAsCollides || !onSaveComplete)
             return;
         onSaveComplete(saveAsTrimmed, saveItems, trimmedDescription || undefined, true);
+        숨은칸비우기();
         setShowSaveAsPopup(false);
     };
     // 저장 버튼 활성 조건 — 인라인 모드에선 이름 필수·중복(others) 불가. 항목이 비어도 불가.
@@ -294,7 +297,7 @@ export default function WordTableBlock({ title, titleIcon, disc, items, onSaveCo
                         items: saveItems,
                         existingNames: getSavedTables().map(tb => tb.name),
                         saveAsNew,
-                        onSave: (name, description) => { onSaveComplete(name, saveItems, description, saveAsNew); setShowSavePopup(false); },
+                        onSave: (name, description) => { onSaveComplete(name, saveItems, description, saveAsNew); 숨은칸비우기(); setShowSavePopup(false); },
                         onCancel: () => setShowSavePopup(false),
                     }), (isEditable || onAddItem) && activeCell !== null && renderWordSearch?.({
                         cellIndex: activeCell,

package/dist/packages/core/src/components/Word/WordTableThumbnail.js

@@ -16,6 +16,6 @@ export default function WordTableThumbnail({ items, className }) {
             const item = items[i];
             if (!item)
                 return _jsx("div", { className: "word-table-thumb__cell word-table-thumb__cell--empty" }, i);
-            return (_jsx("div", { className: "word-table-thumb__cell", children: (item.words.length ? item.words : [{ label: item.id }]).map((w, wi) => (_jsxs(Fragment, { children: [wi > 0 && _jsx("span", { className: "word-table-thumb__divider" }), _jsx("span", { className: "word-table-thumb__word body-3", children: w.label })] }, wi))) }, i));
+            return (_jsx("div", { className: "word-table-thumb__cell", children: (item.words?.length ? item.words : [{ label: item.id }]).map((w, wi) => (_jsxs(Fragment, { children: [wi > 0 && _jsx("span", { className: "word-table-thumb__divider" }), _jsx("span", { className: "word-table-thumb__word body-3", children: w.label })] }, wi))) }, i));
         }) }));
 }

package/dist/packages/core/src/components/Word/useWordTableDisplaySettings.js

@@ -2,9 +2,8 @@
 import { useMemo, useState, useCallback, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
 import { chunkItems } from '../wordTableLayout';
-import { ITEMS_PER_PAGE_OPTIONS } from './wordTableBlockTypes';
 import { getImageResolver, checkImageExists } from '../../utils/imageConfig';
-import { buildCompositionSection, buildOrientationSection, buildBorderSection, buildCutLineSection, buildDivLineSection, buildItemsPerPageSection, buildPageNumberSection, buildTableSettingsSelected, applyTableSettingsSelect, PAGE_NUM_POSITION_VALUE, parsePageNumberPosition, } from './wordTableSettings';
+import { buildCompositionSection, buildOrientationSection, buildBorderSection, buildCutLineSection, buildDivLineSection, buildItemsPerPageSection, buildPageNumberSection, buildTableSettingsSelected, applyTableSettingsSelect, PAGE_NUM_POSITION_VALUE, parsePageNumberPosition, itemsPerPageFromChoice, } from './wordTableSettings';
 /**
  * 표시 전용 단어표(편집 없음)의 '표 설정' FilterPanel 상태·섹션을 제공하는 훅.
  * 구성·용지 방향·외곽선, 내용이 있으면 페이지당 개수, 2페이지 이상이면 페이지 번호, 항목이 2개 이상이면
@@ -22,8 +21,9 @@ export function useWordTableDisplaySettings(items) {
     const [itemsPerPageSetting, setItemsPerPageSetting] = useState(8);
     const [pageNumberPosition, setPageNumberPosition] = useState('right');
     const itemCount = items.length;
-    const hasPairs = items.some(item => item.words.length > 1);
-    const hasColloquial = items.some(item => item.words.some(w => !!w.colloquialLabel));
+    // 저장소에서 온 항목에 words 가 빠져 있을 수 있다({ id }) — 빈 낱말로 본다
+    const hasPairs = items.some(item => (item.words ?? []).length > 1);
+    const hasColloquial = items.some(item => (item.words ?? []).some(w => !!w.colloquialLabel));
     // 페이지 분할 — 페이지당 개수(기본 8, 실제 개수보다 크면 전체로 클램프)로 나눈다. 항목이 없으면 1칸짜리 빈 표.
     const effectiveItemsPerPage = Math.min(itemsPerPageSetting, Math.max(itemCount, 1));
     const pages = useMemo(() => chunkItems(items, effectiveItemsPerPage), [items, effectiveItemsPerPage]);
@@ -41,7 +41,7 @@ export function useWordTableDisplaySettings(items) {
             setHasImage(false);
             return;
         }
-        Promise.all(items.flatMap(item => item.words.map(w => checkImageExists(w.label, w.homonum))))
+        Promise.all(items.flatMap(item => (item.words ?? []).map(w => checkImageExists(w.label, w.homonum))))
             .then(results => { if (!cancelled)
             setHasImage(results.some(Boolean)); }, () => { }); // 거절은 이미지 없음으로 둔다
         return () => { cancelled = true; };
@@ -69,15 +69,12 @@ export function useWordTableDisplaySettings(items) {
         if (applyTableSettingsSelect(t, value, sectionLabel, { setContentTypes, setOrientation, setShowOutline, setCutLine, setShowDivLine }))
             return;
         if (sectionLabel === t('wordTable.filter.itemsPerPagePair', '페이지당 대립쌍 수') || sectionLabel === t('wordTable.filter.itemsPerPageWord', '페이지당 단어 수')) {
-            /* 목록에 없는 개수(= 그때의 '전체' 칸)를 고르면 **전체** 로 기억한다 — 숫자로 담으면 항목이 늘었을 때 고른 값('10개')이
-               선택지([20, 8, 4, 2, 1])에 없어 켜진 칸이 없는데 표는 10개씩 나뉘었다. */
-            const n = parseInt(value);
-            setItemsPerPageSetting(ITEMS_PER_PAGE_OPTIONS.includes(n) ? n : Number.POSITIVE_INFINITY);
+            setItemsPerPageSetting(itemsPerPageFromChoice(parseInt(value), itemCount));
         }
         else if (sectionLabel === t('wordTable.filter.pageNumber', '페이지 번호')) {
             setPageNumberPosition(parsePageNumberPosition(value));
         }
-    }, [t]);
+    }, [t, itemCount]);
     return {
         settings: { orientation, contentTypes, cutLine, showOutline, showDivLine, count },
         filterSections, filterSelected, handleSelect,

package/dist/packages/core/src/components/Word/useWordTablePrint.d.ts

@@ -20,7 +20,7 @@ export interface UseWordTablePrintResult {
     print: () => void;
     /** 새 탭에 단어표를 열어 사용자가 직접 인쇄/저장하게 한다. */
     openNewWindow: () => void;
-    /** 단어표를 정적 HTML 파일로 다운로드한다. */
+    /** 단어표를 정적 HTML 파일로 다운로드한다. 파일명이 비면(걸러 내고 남는 글자가 없으면) 기본 이름('단어표'). */
     downloadHtml: () => void;
 }
 /**

package/dist/packages/core/src/components/Word/useWordTablePrint.js

@@ -1,6 +1,9 @@
 'use client';
 import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
 import { captureHtml, printWordTableElements, sanitizeFileName } from './wordTablePrint';
+/** 내려받기를 누른 뒤 Blob 주소를 회수하기까지(utils/csv 와 같은 값) */
+const BLOB_REVOKE_DELAY_MS = 1000;
 /**
  * 단어표 인쇄/새창/다운로드 액션을 한 곳에서 제공하는 훅. WordTableBlock·WordTablePopup 등
  * 단어표를 보여주는 컴포넌트가 공용으로 쓴다. 실제 문서 생성은 wordTablePrint의 순수 함수가,
@@ -8,6 +11,7 @@ import { captureHtml, printWordTableElements, sanitizeFileName } from './wordTab
  * @public
  */
 export function useWordTablePrint({ getElements, paperW, paperH, fileName = '', onPopupBlocked, header = '', }) {
+    const { t } = useTranslation();
     const print = useCallback(() => {
         printWordTableElements(getElements(), paperW, paperH, fileName, header);
     }, [getElements, paperW, paperH, fileName, header]);
@@ -32,12 +36,14 @@ export function useWordTablePrint({ getElements, paperW, paperH, fileName = '',
         const url = URL.createObjectURL(blob);
         // fileName은 사용자가 지정한 단어표 이름 등에서 올 수 있어, 파일시스템에서 문제되는
         // 문자(\/:*?"<>|)를 치환하지 않으면 다운로드 파일명이 깨지거나 저장이 실패할 수 있다.
-        const safeFileName = fileName ? sanitizeFileName(fileName) : fileName;
+        /* 이름이 비면 기본 이름 — 그대로 두면 '.html' 이라는 이름 없는(숨김) 파일이 내려왔다. */
+        const safeFileName = (fileName ? sanitizeFileName(fileName) : '') || t('wordTable.printFileNameSingle', '단어표');
         const a = Object.assign(document.createElement('a'), { href: url, download: `${safeFileName}.html` });
         document.body.appendChild(a);
         a.click();
         document.body.removeChild(a);
-        URL.revokeObjectURL(url);
-    }, [getElements, paperW, paperH, fileName, header]);
+        /* 곧바로 회수하면 Safari 가 내려받기를 시작하기 전에 주소가 사라져 빈 파일·실패가 됐다 — 조금 늦춘다 */
+        setTimeout(() => URL.revokeObjectURL(url), BLOB_REVOKE_DELAY_MS);
+    }, [getElements, paperW, paperH, fileName, header, t]);
     return { print, openNewWindow, downloadHtml };
 }

package/dist/packages/core/src/components/Word/wordScoreStats.d.ts

@@ -13,12 +13,22 @@ export interface ScoreRecord {
     tableId: string | null;
     /** 칸 번호 → 표시 */
     marks: Record<string, ScoreMark>;
-    /** 칸 번호 → 그때 보인 낱말. 옛 기록에는 없을 수 있다 */
+    /**
+     * 칸 번호 → 그때 보인 낱말. 옛 기록에는 없을 수 있다.
+     * `cellKey` 로 동형어 번호까지 적어 두면(`배#2`) `weakItems` 가 동형어를 따로 센다.
+     */
     labels: Record<string, string>;
 }
 /** 낱말 하나에 대해 쌓인 성적. */
 export interface WeakItem {
+    /** 보이는 낱말 — 동형어 번호를 뗀 글자(`배`, `배 / 패`) */
     label: string;
+    /**
+     * 묶은 열쇠 — 저장된 칸 낱말 그대로. 동형어 번호가 저장된 기록이면 `배#2` 처럼 번호가 붙고,
+     * 없는 옛 기록이면 `label` 과 같다. 같은 `label` 이 둘 이상 나올 수 있으니 줄 열쇠로는 이것을 쓴다.
+     * `weakItems` 는 늘 채운다 — 선택 필드인 것은 이 모양을 손으로 짓는 쪽(시험 등)을 깨지 않으려는 것뿐이다.
+     */
+    key?: string;
     /** 이 낱말을 매긴 횟수 */
     tried: number;
     o: number;
@@ -40,6 +50,9 @@ export interface WeakItem {
  *
  * **낱말이 안 남은 옛 기록은 건너뛴다.** 칸 번호로 표를 되짚으면 그 표가 그동안 바뀌었을 때
  * 엉뚱한 낱말의 기록이 된다 — 조용히 틀리느니 빼는 편이 낫다.
+ *
+ * **동형어는 저장된 낱말에 번호가 있을 때만 따로 묶는다**(`배#1`·`배#2`, `cellKey`). 번호 없이 저장된 옛 기록은
+ * 지금처럼 글자로 묶는다 — 그래서 같은 '배' 가 옛 기록 한 줄·번호 있는 기록 한 줄로 나뉘어 보일 수 있다.
  */
 export declare function weakItems(records: readonly ScoreRecord[]): WeakItem[];
 /** 표 한 개에 대한 흐름 — 같은 표를 여러 번 돌렸을 때 나아지고 있는가. */

package/dist/packages/core/src/components/Word/wordScoreStats.js

@@ -1,4 +1,5 @@
 import { 한글순 } from '../../utils/textSort';
+import { labelOfCellKey } from './wordTableReview';
 /** △ 를 반 점으로 치는 셈 — 저장할 때 서버가 쓰는 규칙과 같다. */
 function 점수(o, triangle, marked) {
     return marked === 0 ? 0 : (o + triangle * 0.5) / marked;
@@ -12,6 +13,9 @@ function 점수(o, triangle, marked) {
  *
  * **낱말이 안 남은 옛 기록은 건너뛴다.** 칸 번호로 표를 되짚으면 그 표가 그동안 바뀌었을 때
  * 엉뚱한 낱말의 기록이 된다 — 조용히 틀리느니 빼는 편이 낫다.
+ *
+ * **동형어는 저장된 낱말에 번호가 있을 때만 따로 묶는다**(`배#1`·`배#2`, `cellKey`). 번호 없이 저장된 옛 기록은
+ * 지금처럼 글자로 묶는다 — 그래서 같은 '배' 가 옛 기록 한 줄·번호 있는 기록 한 줄로 나뉘어 보일 수 있다.
  */
 export function weakItems(records) {
     const 모음 = new Map();
@@ -38,11 +42,11 @@ export function weakItems(records) {
         }
     }
     const out = [];
-    for (const [label, v] of 모음) {
+    for (const [key, v] of 모음) {
         const tried = v.o + v.triangle + v.x;
-        out.push({ label, tried, o: v.o, triangle: v.triangle, x: v.x, rate: 점수(v.o, v.triangle, tried), latest: v.latest, latestAt: v.latestAt });
+        out.push({ label: labelOfCellKey(key), key, tried, o: v.o, triangle: v.triangle, x: v.x, rate: 점수(v.o, v.triangle, tried), latest: v.latest, latestAt: v.latestAt });
     }
-    out.sort((a, b) => a.rate - b.rate || b.tried - a.tried || 한글순(a.label, b.label));
+    out.sort((a, b) => a.rate - b.rate || b.tried - a.tried || 한글순(a.label, b.label) || 한글순(a.key ?? a.label, b.key ?? b.label));
     return out;
 }
 /**

package/dist/packages/core/src/components/Word/wordTablePrint.js

@@ -229,19 +229,31 @@ export function captureHtml(els, paperW, paperH, autoPrint = false, fileName = '
     ${autoPrint ? `
     // document.write 직후 바로 window.print()를 부르면 이미지(비동기 로드)와
     // 레이아웃이 아직 반영되기 전이라 빈 페이지로 인쇄되는 경우가 있어,
-    // 모든 <img> 로드 완료 + rAF 2틱(레이아웃/페인트 확정) 이후에 인쇄한다.
+    // 모든 <img> 로드 완료 + 글꼴 준비(최대 1초) + rAF 2틱(레이아웃/페인트 확정) 이후에 인쇄한다.
+    // 글꼴을 안 기다리면 웹 글꼴이 오기 전에 인쇄돼 기본 글꼴 종이가 나왔다(document.fonts 가 없으면 기다리지 않는다).
     (function () {
       var MAX_WAIT_MS = 3000;
+      var FONT_WAIT_MS = 1000;
       var timedOut = false;
+      var printed = false;
       var timer = setTimeout(function () { timedOut = true; afterReady(); }, MAX_WAIT_MS);
       var pending = Array.prototype.filter.call(document.images, function (img) { return !img.complete; });
       var remaining = pending.length;
-      function afterReady() {
-        if (timer) { clearTimeout(timer); timer = null; }
+      function printNow() {
+        if (printed) return;
+        printed = true;
         requestAnimationFrame(function () {
           requestAnimationFrame(function () { window.print(); });
         });
       }
+      function afterReady() {
+        if (timer) { clearTimeout(timer); timer = null; }
+        var fonts = null;
+        try { fonts = document.fonts && document.fonts.ready; } catch (e) { fonts = null; }
+        if (!fonts || typeof fonts.then !== 'function') { printNow(); return; }
+        setTimeout(printNow, FONT_WAIT_MS);
+        fonts.then(printNow, printNow);
+      }
       if (remaining === 0) { afterReady(); return; }
       pending.forEach(function (img) {
         function done() { if (timedOut) return; remaining--; if (remaining <= 0) afterReady(); }

package/dist/packages/core/src/components/Word/wordTableReview.d.ts

@@ -14,14 +14,53 @@ import type { ScoreMark } from './wordTableScoring';
  * 이미 아는 표와 닮아 있는 편이 쓰기에도 낫다.
  */
 export declare function reviewCells<T>(items: readonly T[], marks: Record<string, ScoreMark | null | undefined>): T[];
+/**
+ * 복습할 원래 표 — 이름과, 있으면 **복습 메타**.
+ *
+ * 이름만으로는 회차를 틀리게 읽을 때가 있다. `수업 3차` 라는 표의 복습(`수업 3차 복습 09.15`)과
+ * `수업` 의 3차 복습(`수업 3차 복습 09.15`)이 **같은 이름**이라, 다시 복습하면 둘 다 `수업 4차 복습` 이 됐다.
+ * 복습표를 저장할 때 {@link reviewMeta} 의 값을 함께 남겨 두면 이름을 파싱하지 않고 그 값을 쓴다.
+ * 메타가 없는 옛 표는 지금처럼 이름을 파싱한다.
+ *
+ * @public
+ */
+export interface ReviewSource {
+    /** 표 이름 */
+    name: string;
+    /** 표 id — 이 표가 원본이면 복습표의 `reviewOf` 가 된다 */
+    id?: string;
+    /** 이 표가 복습표면 **맨 처음 원본 표**의 id */
+    reviewOf?: string | null;
+    /**
+     * 이 표가 몇 번째 복습인가(1부터). `0` 은 "복습표가 아니다" — 이름이 `… 복습 09.01` 꼴이어도 꼬리로 떼지 않는다.
+     * 없으면(`undefined`·`null`) 옛 표로 보고 이름을 파싱한다.
+     */
+    reviewRound?: number | null;
+}
 /**
  * 복습표 이름.
  *
  * 원래 이름을 앞에 두어 **목록에서 나란히 붙어 보이게** 한다(대개 이름순·최신순으로 본다).
  * 날짜를 붙이는 것은 같은 표를 여러 번 돌리기 때문이다 — 없으면 같은 이름이 쌓여
  * 어느 것이 이번 것인지 알 수 없다.
+ *
+ * 이름 형식(`바탕 [N차 ]복습 MM.DD`)은 저장된 이름·파싱과 맞추느라 바꾸지 않는다.
+ * 원래 표를 {@link ReviewSource} 로 넘기면 복습 메타(`reviewRound`)를 이름 파싱보다 먼저 쓴다 —
+ * 새 복습표를 저장할 때는 {@link reviewMeta} 의 값을 함께 남긴다. 글자만 넘기면 지금처럼 이름을 파싱한다.
+ */
+export declare function reviewTableName(original: string | ReviewSource, today: Date): string;
+/**
+ * 새로 만들 복습표에 **함께 저장할 메타** — 맨 처음 원본 표 id 와 이번이 몇 번째 복습인지.
+ *
+ * `reviewOf` 는 원래 표가 복습표면 그 표의 `reviewOf` 를, 아니면 원래 표의 `id` 를 잇는다(둘 다 없으면 `undefined`).
+ * `reviewRound` 는 {@link reviewTableName} 이 이름에 적는 회차와 같다(1 = 첫 복습).
+ *
+ * @public
  */
-export declare function reviewTableName(original: string, today: Date): string;
+export declare function reviewMeta(source: ReviewSource): {
+    reviewOf: string | undefined;
+    reviewRound: number;
+};
 /**
  * 칸 번호 → 그때 보인 낱말. 채점과 **함께 저장한다.**
  *
@@ -37,6 +76,24 @@ export declare function labelsForSave(labels: readonly string[], marks: Record<s
 export declare function cellLabel(words: readonly {
     label: string;
 }[]): string;
+/**
+ * 한 칸의 낱말들을 **동형어 번호까지** 한 줄로 — `배#2 / 패`. 번호가 없는 낱말은 {@link cellLabel} 과 같다.
+ *
+ * 채점과 함께 저장하는 칸 낱말(`labelsForSave` 에 넘길 것)로 쓰면 `weakItems` 가 '배'(1)·'배'(2) 를 따로 센다.
+ * 글자만(`cellLabel`) 저장하면 둘의 성적이 한 줄로 합쳐진다. 화면에 보일 글자는 {@link labelOfCellKey} 로 되돌린다.
+ *
+ * @public
+ */
+export declare function cellKey(words: readonly {
+    label: string;
+    homonum?: number | null;
+}[]): string;
+/**
+ * {@link cellKey} 로 만든 칸 낱말에서 동형어 번호를 뗀 보이는 글자 — `배#2 / 패` → `배 / 패`. 번호가 없으면 그대로.
+ *
+ * @public
+ */
+export declare function labelOfCellKey(key: string): string;
 /**
  * 채점한 표를 인쇄할 때 종이 맨 위에 찍는 한 줄.
  *