@ihabdevteam/core 0.322.0 → 0.324.0

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

@@ -8,27 +8,27 @@ import { FOCUSABLE_SELECTOR } from './useFocusTrap';
  * 미리보기와 함께 사라진다. 확인 창을 닫으면 떼어진 단추에 focus() 해 아무 일도 없이 body 에 떨어졌다.
  * 각 창의 판(panel) → 그 창이 돌려줄 곳을 적어 두고, 돌려줄 곳이 떼어졌으면 그것을 품었던 창의 돌려줄 곳을 따라 올라간다.
  */
-const 돌아갈곳표 = new WeakMap();
+const returnTargets = new WeakMap();
 /** 창 판과, 그 창이 열릴 때 포커스였던 요소를 적는다 */
 export function rememberFocusReturn(panel, previouslyFocused) {
     if (panel)
-        돌아갈곳표.set(panel, previouslyFocused);
+        returnTargets.set(panel, previouslyFocused);
 }
 /** 실제로 돌려줄 곳 — 문서에 붙어 있으면 그대로, 떼어졌으면 그것을 품었던 창이 적어 둔 곳을 따라간다 */
 export function resolveFocusReturn(previouslyFocused) {
-    let 대상 = previouslyFocused;
-    for (let 번 = 0; 대상 && !대상.isConnected && 번 < 10; 번++) {
-        let 창 = 대상;
-        while (창 && !돌아갈곳표.has(창))
-            창 = 창.parentElement;
-        if (!창)
-            return 대상;
-        대상 = 돌아갈곳표.get(창) ?? null;
+    let target = previouslyFocused;
+    for (let hop = 0; target && !target.isConnected && hop < 10; hop++) {
+        let node = target;
+        while (node && !returnTargets.has(node))
+            node = node.parentElement;
+        if (!node)
+            return target;
+        target = returnTargets.get(node) ?? null;
     }
-    return 대상;
+    return target;
 }
 /* 포커스를 받을 수 있는가 — 붙어 있고, 막히지 않았고, inert·aria-hidden·hidden 아래가 아니다(레이아웃은 재지 않는다: 시험 환경에 없다) */
-function 받을수있나(el) {
+function canFocus(el) {
     if (!el || !el.isConnected || el === document.body)
         return false;
     if (typeof el.focus !== 'function')
@@ -53,24 +53,24 @@ function 받을수있나(el) {
  * 옮긴 요소를 돌려준다(못 옮기면 null).
  */
 export function moveFocusOutside(container, opener, anchor) {
-    const 기준 = container?.isConnected ? container : anchor?.isConnected ? anchor : null;
-    if (받을수있나(opener) && !(container && container.contains(opener))) {
+    const anchorNode = container?.isConnected ? container : anchor?.isConnected ? anchor : null;
+    if (canFocus(opener) && !(container && container.contains(opener))) {
         opener.focus();
         return opener;
     }
-    if (!기준)
+    if (!anchorNode)
         return null;
-    const 모두 = Array.from(document.querySelectorAll(FOCUSABLE_SELECTOR))
-        .filter((el) => !(container && container.contains(el)) && 받을수있나(el));
-    let 앞 = null;
-    let 뒤 = null;
-    for (const el of 모두) {
-        if (기준.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING)
-            앞 = el;
-        else if (!뒤)
-            뒤 = el;
+    const allFocusable = Array.from(document.querySelectorAll(FOCUSABLE_SELECTOR))
+        .filter((el) => !(container && container.contains(el)) && canFocus(el));
+    let before = null;
+    let after = null;
+    for (const el of allFocusable) {
+        if (anchorNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING)
+            before = el;
+        else if (!after)
+            after = el;
     }
-    const 대상 = 앞 ?? 뒤;
-    대상?.focus();
-    return 대상;
+    const target = before ?? after;
+    target?.focus();
+    return target;
 }

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

@@ -6,26 +6,26 @@
  * 초점을 옮겨 그 단추의 초점 툴팁이 떴다(듣기 → '재생 / 멈춤', 문장 미리보기 → '글자 크기 감소'). Safari 는 누른 단추에 초점을
  * 안 줘 body 에 남는다. 문서 전체에서 키 누름·포인터 누름을 들어 마지막 것을 기억한다(캡처 단계, 한 번만 붙인다).
  */
-let 마지막 = null;
-let 붙음 = false;
-function 붙이기() {
-    if (붙음 || typeof document === 'undefined')
+let last = null;
+let attached = false;
+function attach() {
+    if (attached || typeof document === 'undefined')
         return;
-    붙음 = true;
+    attached = true;
     document.addEventListener('keydown', (e) => {
         if (e.metaKey || e.ctrlKey || e.altKey)
             return;
-        마지막 = 'keyboard';
+        last = 'keyboard';
     }, true);
-    const 포인터 = () => { 마지막 = 'pointer'; };
-    document.addEventListener('pointerdown', 포인터, true);
-    document.addEventListener('mousedown', 포인터, true);
-    document.addEventListener('touchstart', 포인터, { capture: true, passive: true });
+    const onPointer = () => { last = 'pointer'; };
+    document.addEventListener('pointerdown', onPointer, true);
+    document.addEventListener('mousedown', onPointer, true);
+    document.addEventListener('touchstart', onPointer, { capture: true, passive: true });
 }
 // 불러오는 즉시 듣는다 — 첫 누름부터 알아야 한다
-붙이기();
+attach();
 /** 마지막 입력이 키보드였으면 true(모르면 false) */
 export function wasKeyboardPress() {
-    붙이기();
-    return 마지막 === 'keyboard';
+    attach();
+    return last === 'keyboard';
 }

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

@@ -12,25 +12,25 @@ import { useLatestRef } from './useLatestRef';
  * 마우스 동작은 그대로 두고, pointerType 이 touch 일 때만: 들어오고 나감은 무시 · 뗄 때 뒤집기 · 방금 톡으로 온 focus 는 무시 ·
  * 바깥을 톡하면 닫기.
  */
-let 마지막터치 = 0;
-let 붙음 = false;
-function 붙이기() {
-    if (붙음 || typeof document === 'undefined')
+let lastTouchAt = 0;
+let attached = false;
+function attach() {
+    if (attached || typeof document === 'undefined')
         return;
-    붙음 = true;
+    attached = true;
     document.addEventListener('pointerdown', (e) => { if (e.pointerType === 'touch')
-        마지막터치 = Date.now(); }, true);
-    document.addEventListener('touchstart', () => { 마지막터치 = Date.now(); }, { capture: true, passive: true });
+        lastTouchAt = Date.now(); }, true);
+    document.addEventListener('touchstart', () => { lastTouchAt = Date.now(); }, { capture: true, passive: true });
 }
-붙이기();
+attach();
 /** 터치 포인터 이벤트인가 */
 export function isTouchPointer(e) {
     return !!e && e.pointerType === 'touch';
 }
 /** 방금(1초 안) 화면을 톡했나 — 톡 뒤 따라오는 focus·호환 마우스 이벤트를 거를 때 */
 export function recentlyTouched(ms = 1000) {
-    붙이기();
-    return Date.now() - 마지막터치 < ms;
+    attach();
+    return Date.now() - lastTouchAt < ms;
 }
 /**
  * 톡으로 뒤집는 손잡이. `open` 은 지금 열림, `setOpen(next, el)` 은 열기(el 은 앵커)·닫기.
@@ -45,39 +45,39 @@ export function useTouchToggle(open, setOpen, rootRef, { enabled = true, fallbac
     const openRef = useLatestRef(open);
     const setOpenRef = useLatestRef(setOpen);
     /** 이 트리거 위 톡 누름 때의 열림(null 이면 톡 누름이 아니었다) */
-    const 누를때열림 = useRef(null);
-    const 뒤집은시각 = useRef(0);
+    const openOnPress = useRef(null);
+    const toggledAt = useRef(0);
     useEffect(() => {
         if (!enabled || typeof document === 'undefined')
             return;
-        const 누름 = (ev) => {
+        const onPress = (ev) => {
             const pe = ev;
             const t = ev.target;
             const root = rootRef.current;
-            const 안 = !!(t && root && root.contains(t));
+            const inside = !!(t && root && root.contains(t));
             if (pe.pointerType !== 'touch') {
-                if (안)
-                    누를때열림.current = null;
+                if (inside)
+                    openOnPress.current = null;
                 return;
             }
-            if (안) {
-                누를때열림.current = openRef.current;
+            if (inside) {
+                openOnPress.current = openRef.current;
                 return;
             }
-            누를때열림.current = null;
+            openOnPress.current = null;
             if (openRef.current && !(t && t.closest?.('.tooltip-content')))
                 setOpenRef.current(false, root);
         };
-        document.addEventListener('pointerdown', 누름, true);
-        return () => document.removeEventListener('pointerdown', 누름, true);
+        document.addEventListener('pointerdown', onPress, true);
+        return () => document.removeEventListener('pointerdown', onPress, true);
     }, [enabled, rootRef, openRef, setOpenRef]);
     const touchPress = useCallback((el) => {
-        const 전 = 누를때열림.current;
-        if (전 === null)
+        const before = openOnPress.current;
+        if (before === null)
             return false;
-        누를때열림.current = null;
-        뒤집은시각.current = Date.now();
-        setOpenRef.current(!전, el ?? rootRef.current);
+        openOnPress.current = null;
+        toggledAt.current = Date.now();
+        setOpenRef.current(!before, el ?? rootRef.current);
         return true;
     }, [rootRef, setOpenRef]);
     /* 막힌 native 단추 — 포인터 이벤트가 안 오면 감싼 요소에서 톡(touchstart→touchend)을 받아 자리로 가린다 */
@@ -88,27 +88,27 @@ export function useTouchToggle(open, setOpen, rootRef, { enabled = true, fallbac
         const parent = root?.parentElement;
         if (!root || !parent)
             return;
-        let 시작때열림 = null;
-        const 안에있나 = (e) => {
+        let openAtStart = null;
+        const isInside = (e) => {
             const p = e.changedTouches?.[0];
             if (!p)
                 return false;
             const r = root.getBoundingClientRect();
             return p.clientX >= r.left && p.clientX <= r.right && p.clientY >= r.top && p.clientY <= r.bottom;
         };
-        const 시작 = (e) => { 시작때열림 = 안에있나(e) ? openRef.current : null; };
-        const 끝 = (e) => {
-            const 전 = 시작때열림;
-            시작때열림 = null;
-            if (전 === null || Date.now() - 뒤집은시각.current < 700 || !안에있나(e))
+        const onStart = (e) => { openAtStart = isInside(e) ? openRef.current : null; };
+        const onEnd = (e) => {
+            const before = openAtStart;
+            openAtStart = null;
+            if (before === null || Date.now() - toggledAt.current < 700 || !isInside(e))
                 return;
-            누를때열림.current = null;
-            뒤집은시각.current = Date.now();
-            setOpenRef.current(!전, root);
+            openOnPress.current = null;
+            toggledAt.current = Date.now();
+            setOpenRef.current(!before, root);
         };
-        parent.addEventListener('touchstart', 시작, { passive: true });
-        parent.addEventListener('touchend', 끝);
-        return () => { parent.removeEventListener('touchstart', 시작); parent.removeEventListener('touchend', 끝); };
+        parent.addEventListener('touchstart', onStart, { passive: true });
+        parent.addEventListener('touchend', onEnd);
+        return () => { parent.removeEventListener('touchstart', onStart); parent.removeEventListener('touchend', onEnd); };
     }, [enabled, fallbackOnParent, rootRef, openRef, setOpenRef]);
     return { touchPress };
 }

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

@@ -10,15 +10,15 @@ import { pushEsc } from './escStack';
  * 트리거 조상 가운데 가장 높은 z-index 바로 위(없으면 `--z-menu`)로 둔다. 그 층들은 모두 알림·토스트 아래다.
  */
 export function anchoredMenuZIndex(trigger) {
-    let 가장높은 = 0;
+    let tallest = 0;
     if (trigger && typeof window !== 'undefined' && typeof window.getComputedStyle === 'function') {
         for (let el = trigger; el && el !== document.body && el !== document.documentElement; el = el.parentElement) {
             const z = parseInt(window.getComputedStyle(el).zIndex, 10);
-            if (!Number.isNaN(z) && z > 가장높은)
-                가장높은 = z;
+            if (!Number.isNaN(z) && z > tallest)
+                tallest = z;
         }
     }
-    return 가장높은 > 0 ? `max(var(--z-menu, 1500), ${가장높은 + 1})` : 'var(--z-menu, 1500)';
+    return tallest > 0 ? `max(var(--z-menu, 1500), ${tallest + 1})` : 'var(--z-menu, 1500)';
 }
 /**
  * 트리거 요소에 fixed 포지션으로 앵커링되는 메뉴/드롭다운/팝오버의 공용 로직.
@@ -53,28 +53,28 @@ export function useAnchoredMenu({ computeStyle, onScroll = 'close', onResize = '
            (약 40px)이 오르내린다. 높이가 바뀔 때마다 다시 센다.
            **높이가 달라졌을 때만** 다시 센다 — 안 그러면 셈이 자리를 바꾸고 자리가 다시
            셈을 불러 끝없이 돈다. */
-        let 잰높이 = menuRef.current?.offsetHeight ?? 0;
-        if (잰높이 > 0)
+        let measuredHeight = menuRef.current?.offsetHeight ?? 0;
+        if (measuredHeight > 0)
             recalc();
         /* **오가는 것을 끊는다.** 높이가 달라질 때만 세는 것으로는 두 꼴을 번갈아 오가는 것을
            못 막는다(A 로 자리를 잡으면 높이가 B 가 되고, B 로 잡으면 다시 A 가 되는 꼴).
            한 번 여는 동안 몇 번까지만 센다 — 제대로 된 다시 재기는 한두 번이면 끝난다. */
-        let 센횟수 = 0;
-        let 판관찰 = null;
+        let measureCount = 0;
+        let panelObserver = null;
         if (typeof ResizeObserver !== 'undefined' && menuRef.current) {
-            판관찰 = new ResizeObserver(() => {
+            panelObserver = new ResizeObserver(() => {
                 const h = menuRef.current?.offsetHeight ?? 0;
-                if (h === 잰높이)
+                if (h === measuredHeight)
                     return;
-                잰높이 = h;
-                if (++센횟수 > 4) {
-                    판관찰?.disconnect();
-                    판관찰 = null;
+                measuredHeight = h;
+                if (++measureCount > 4) {
+                    panelObserver?.disconnect();
+                    panelObserver = null;
                     return;
                 }
                 recalc();
             });
-            판관찰.observe(menuRef.current);
+            panelObserver.observe(menuRef.current);
         }
         const handleOutsideClick = (e) => {
             const target = e.target;
@@ -94,21 +94,21 @@ export function useAnchoredMenu({ computeStyle, onScroll = 'close', onResize = '
            capture 로** 받는다 — `DatePicker` 가 `onScroll: 'reposition'` 을 주므로 달력이 열린 동안 굴리면
            틀마다 여러 번 돌았다. **닫는 길('close')은 안 미룬다** — 미루면 앵커에서 떨어진 판이 한 틀 더
            허공에 남는다(Tooltip 과 같은 가름). 미루는 것은 *자리* 뿐이다. */
-        let 자리예약 = null;
-        const 자리다시 = () => {
+        let rafId = null;
+        const reposition = () => {
             if (typeof requestAnimationFrame === 'undefined') {
                 recalc();
                 return;
             }
-            if (자리예약 !== null)
+            if (rafId !== null)
                 return;
-            자리예약 = requestAnimationFrame(() => { 자리예약 = null; recalc(); });
+            rafId = requestAnimationFrame(() => { rafId = null; recalc(); });
         };
         const handleScroll = (e) => {
             if (menuRef.current?.contains(e.target))
                 return;
             if (onScroll === 'reposition')
-                자리다시();
+                reposition();
             else if (onScroll === 'close')
                 setOpen(false);
         };
@@ -116,17 +116,17 @@ export function useAnchoredMenu({ computeStyle, onScroll = 'close', onResize = '
             window.addEventListener('scroll', handleScroll, true);
         const handleResize = () => {
             if (onResize === 'reposition')
-                자리다시();
+                reposition();
             else if (onResize === 'close')
                 setOpen(false);
         };
         /* 회전(orientationchange)도 함께 — iOS Safari 는 회전 직후 resize 가 늦거나 옛 크기로 오는 일이 있어 회전 뒤 한 번 더 잰다 */
-        let 회전타이머 = null;
+        let rotateTimer = null;
         const handleOrientation = () => {
             handleResize();
-            if (회전타이머)
-                clearTimeout(회전타이머);
-            회전타이머 = setTimeout(() => { 회전타이머 = null; if (onResize === 'reposition')
+            if (rotateTimer)
+                clearTimeout(rotateTimer);
+            rotateTimer = setTimeout(() => { rotateTimer = null; if (onResize === 'reposition')
                 recalc(); }, 250);
         };
         if (onResize !== 'ignore') {
@@ -134,9 +134,9 @@ export function useAnchoredMenu({ computeStyle, onScroll = 'close', onResize = '
             window.addEventListener('orientationchange', handleOrientation);
         }
         return () => {
-            if (자리예약 !== null)
-                cancelAnimationFrame(자리예약);
-            판관찰?.disconnect();
+            if (rafId !== null)
+                cancelAnimationFrame(rafId);
+            panelObserver?.disconnect();
             document.removeEventListener('mousedown', handleOutsideClick);
             document.removeEventListener('pointerdown', handleOutsideClick);
             if (onScroll !== 'ignore')
@@ -145,8 +145,8 @@ export function useAnchoredMenu({ computeStyle, onScroll = 'close', onResize = '
                 window.removeEventListener('resize', handleResize);
                 window.removeEventListener('orientationchange', handleOrientation);
             }
-            if (회전타이머)
-                clearTimeout(회전타이머);
+            if (rotateTimer)
+                clearTimeout(rotateTimer);
         };
     }, [open, recalc, onScroll, onResize, ignoreOutsideClickSelector]);
     /* ESC 로 닫기 — **공유 ESC 스택**에 올린다(Popup 과 같은 스택). 전에는 document 에서 따로 들어,

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

@@ -34,25 +34,25 @@ export function useDailyTrainingSelection(userId) {
     const [hasData, setHasData] = useState(false);
     /* 오늘(KST) — 자정을 넘기면 바뀌어 아래 선택을 **새 날짜 시드로** 다시 계산하게 한다. 전에는 userId 만 봐서 화면을 열어 둔 채
        자정을 넘기면 어제 시드의 세트가 '오늘' 로 보이는데 완료 기록에는 새 날짜가 찍혔다. */
-    const [오늘, set오늘] = useState(() => getTodayKst());
+    const [today, setToday] = 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);
+        const msUntilMidnight = () => {
+            const now = Date.now();
+            const kst = new Date(now + 9 * 3600_000);
+            const midnight = Date.UTC(kst.getUTCFullYear(), kst.getUTCMonth(), kst.getUTCDate() + 1) - 9 * 3600_000;
+            return Math.max(1000, midnight - now + 1000);
         };
-        let t = setTimeout(function 넘김() { set오늘(getTodayKst()); t = setTimeout(넘김, 다음자정까지()); }, 다음자정까지());
+        let t = setTimeout(function tick() { setToday(getTodayKst()); t = setTimeout(tick, msUntilMidnight()); }, msUntilMidnight());
         return () => clearTimeout(t);
     }, []);
     useEffect(() => {
         let cancelled = false;
-        let 떠남 = false;
-        let 적용됨 = false;
+        let left = false;
+        let applied = false;
         let timer;
         let attempts = 0;
-        let 받는중 = null;
-        let 다음받기 = 0; // 이 attempts 에 이르면 자료 받기를 다시 청한다(2초 = 8틱마다)
+        let fetching = null;
+        let nextFetchAt = 0; // 이 attempts 에 이르면 자료 받기를 다시 청한다(2초 = 8틱마다)
         const MAX_ATTEMPTS = 40; // 250ms * 40 = 10초 후 폴링 중단(풀이 영영 비는 경우 무한루프 방지)
         const stop = () => { if (timer !== undefined) {
             clearInterval(timer);
@@ -66,9 +66,9 @@ export function useDailyTrainingSelection(userId) {
         }
         catch { }
         const apply = (sel) => {
-            if (떠남)
+            if (left)
                 return;
-            적용됨 = true;
+            applied = true;
             todayRef.current = sel.today;
             yesterdayRef.current = sel.yesterday;
             setLoaded(true);
@@ -92,19 +92,19 @@ export function useDailyTrainingSelection(userId) {
                배포(형식 오류)에서 10초에 850KB 자료를 40번 받았다. 그 사이 폴링은 선택만 다시 계산한다. */
             /* **받는 중이면 이 틱은 건너뛴다** — 받기는 3초까지 기다리는데 250ms 틱이 그 사이 attempts 가 안 오른 채 들어와
                ensureTrainingDataLoaded 를 매번 새로 불러, 끝나지 않은 받기마다 3초 타이머가 열두 개씩 쌓였다. 진행 중인 약속을 하나만 둔다. */
-            if (받는중) {
+            if (fetching) {
                 if (++attempts >= MAX_ATTEMPTS)
-                    포기();
+                    giveUp();
                 return;
             } // 건너뛴 틱도 10초 시한에 센다
-            if (attempts >= 다음받기) {
-                다음받기 = attempts + 8;
-                받는중 = ensureTrainingDataLoaded(3000).catch(() => false);
+            if (attempts >= nextFetchAt) {
+                nextFetchAt = attempts + 8;
+                fetching = ensureTrainingDataLoaded(3000).catch(() => false);
                 try {
-                    await 받는중;
+                    await fetching;
                 }
                 finally {
-                    받는중 = null;
+                    fetching = null;
                 }
                 if (cancelled)
                     return;
@@ -118,35 +118,35 @@ export function useDailyTrainingSelection(userId) {
             // 포기한다. hasData 를 반드시 false 로 되돌린다 — userId 가 바뀌어 다시 돌 때,
             // 앞 사람 것이 성공했다면 true 로 남아 있어 "자료가 있다" 고 거짓말하게 된다.
             if (++attempts >= MAX_ATTEMPTS)
-                포기();
+                giveUp();
         };
-        function 포기() { setLoaded(true); setHasData(false); cancelled = true; stop(); }
+        function giveUp() { setLoaded(true); setHasData(false); cancelled = true; stop(); }
         /* 포기한 뒤(10초)라도 자료가 도착하면 다시 계산한다 — 느린 회선에서 13초 걸려 받은 회원은 새로고침 전까지 "자료를 못 찾음" 에 남았다 */
-        const 자료도착 = () => {
-            if (떠남 || 적용됨)
+        const onData = () => {
+            if (left || applied)
                 return;
             const sel = resolveSelection(forceRefresh, undefined, userId);
             if (hasItems(sel.today))
                 apply(sel);
         };
         try {
-            window.addEventListener('speechear.data.updated', 자료도착);
+            window.addEventListener('speechear.data.updated', onData);
         }
         catch { }
         tryFill();
         timer = setInterval(tryFill, 250);
         return () => {
             cancelled = true;
-            떠남 = true;
+            left = true;
             stop();
             try {
-                window.removeEventListener('speechear.data.updated', 자료도착);
+                window.removeEventListener('speechear.data.updated', onData);
             }
             catch { }
         };
         // 오늘 은 날짜가 바뀌었다는 신호 — resolveSelection 이 안에서 오늘 날짜를 읽는다
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [userId, 오늘]);
+    }, [userId, today]);
     const getTrainingPerType = useCallback((typeKey) => {
         const src = showYesterday ? yesterdayRef.current : todayRef.current;
         const fallback = showYesterday ? todayRef.current : yesterdayRef.current;

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

@@ -26,8 +26,8 @@ export const DocumentTitleSuppressContext = createContext(false);
 /* 제목을 건 화면들 — 나중에 건 것이 위. 떠날 때 **남은 맨 위 제목**으로 돌린다.
    전에는 저마다 건 순간의 제목(prev)을 기억했다가 되돌려, A 가 떠 있는 동안 B 가 붙고 A 가 나중에 떠나면
    A 의 prev 로 돌아가 B 의 제목이 지워졌다(말귀 CustomersPage 가 겪고 우회해 둠). */
-const 걸린제목 = [];
-let 처음제목 = null;
+const titleStack = [];
+let originalTitle = null;
 /**
  * 현재 화면의 제목을 `document.title`에 반영한다 — `'<제목> · <앱 이름>'`.
  *
@@ -47,16 +47,16 @@ export function useDocumentTitle(title) {
             return;
         if (typeof title !== 'string' || !title)
             return;
-        if (걸린제목.length === 0)
-            처음제목 = document.title;
-        const 칸 = { text: BASE_TITLE ? `${title}${SEP}${BASE_TITLE}` : title };
-        걸린제목.push(칸);
-        document.title = 칸.text;
+        if (titleStack.length === 0)
+            originalTitle = document.title;
+        const entry = { text: BASE_TITLE ? `${title}${SEP}${BASE_TITLE}` : title };
+        titleStack.push(entry);
+        document.title = entry.text;
         return () => {
-            const i = 걸린제목.lastIndexOf(칸);
+            const i = titleStack.lastIndexOf(entry);
             if (i >= 0)
-                걸린제목.splice(i, 1);
-            document.title = 걸린제목.length ? 걸린제목[걸린제목.length - 1].text : (처음제목 ?? document.title);
+                titleStack.splice(i, 1);
+            document.title = titleStack.length ? titleStack[titleStack.length - 1].text : (originalTitle ?? document.title);
         };
     }, [title, suppressed]);
 }

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

@@ -43,13 +43,13 @@ export function useEditableList(emptyItem, initialList = []) {
     /* 편집이 **취소로** 끝나면 그 사이 건너뛴 목록을 받는다 — 전에는 initialList 가 바뀔 때만 돌아, 편집 중 들어온 서버 목록이
        취소한 뒤에도 끝내 안 보였다(방문 예정을 고치다 취소하면 그 사이 다른 방문이 빠진 채). commitEdit 으로 끝난 때는
        방금 커밋한 편집을 옛 목록으로 덮지 않도록 한 번 넘긴다(다음 목록이 오면 그때 받는다). */
-    const 커밋으로끝남Ref = useRef(false);
+    const endedByCommitRef = useRef(false);
     const prevInitialRef = useRef(null);
     useEffect(() => {
         if (isEditing)
             return;
-        if (커밋으로끝남Ref.current) {
-            커밋으로끝남Ref.current = false;
+        if (endedByCommitRef.current) {
+            endedByCommitRef.current = false;
             return;
         }
         const prev = prevInitialRef.current;
@@ -80,7 +80,7 @@ export function useEditableList(emptyItem, initialList = []) {
         setSelected(updated);
         // 편집 중이었을 때만 표시한다(편집이 아닌데 표시하면 다음 목록 한 번을 헛되이 건너뛴다). 같은 값을 넣는 표시라 두 번 불려도 같다
         setIsEditing(prev => { if (prev)
-            커밋으로끝남Ref.current = true; return false; });
+            endedByCommitRef.current = true; return false; });
     }, []);
     const remove = useCallback((item) => {
         setList(prev => prev.filter(v => !isSameEditableItem(v, item)));

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

@@ -40,8 +40,8 @@ export function useFocusTrap(panelRef, enabled = true) {
             const active = document.activeElement;
             /* 포커스가 **판 자체**(tabIndex=-1 — 본문 글자를 누르면 판이 받는다)에 있으면 첫 칸·끝 칸 어느 쪽도 아니라
                되감지 않아, Shift+Tab 한 번에 뒤 화면으로 나갔다. 판 자체면 Shift+Tab 은 끝 칸으로 보낸다. */
-            const 판자체 = active === panel;
-            if (e.shiftKey && (active === first || 판자체)) {
+            const onPanelItself = active === panel;
+            if (e.shiftKey && (active === first || onPanelItself)) {
                 e.preventDefault();
                 last.focus();
             }

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

@@ -5,7 +5,7 @@ export default function useFontScale({ storageKey = 'fontScale',
 // 기본값을 중앙화: Training/Tooltip 텍스트 박스 공통값
 baseFont = 20, minScale = 0.8, maxScale = 1.4, step = 0.1, lineHeightRatio = 1.4, } = {}) {
     const clamp = (v) => Math.max(minScale, Math.min(maxScale, Number(v)));
-    const 읽기 = (key) => {
+    const read = (key) => {
         try {
             const raw = localStorage.getItem(key);
             const parsed = raw ? Number(raw) : 1;
@@ -21,13 +21,13 @@ baseFont = 20, minScale = 0.8, maxScale = 1.4, step = 0.1, lineHeightRatio = 1.4
             return clamp(1);
         }
     };
-    const [scale, setScaleRaw] = useState(() => 읽기(storageKey));
+    const [scale, setScaleRaw] = useState(() => read(storageKey));
     /* 열쇠가 바뀌면 **그 열쇠의 저장값** 으로 — 전에는 앞 열쇠의 값을 들고 있다가 아래 쓰기가 새 열쇠의 저장값을 덮었다.
        렌더 중에 맞추므로 쓰기 effect 는 새 값으로만 돈다. */
-    const [읽은열쇠, set읽은열쇠] = useState(storageKey);
-    if (읽은열쇠 !== storageKey) {
-        set읽은열쇠(storageKey);
-        setScaleRaw(읽기(storageKey));
+    const [loadedKey, setLoadedKey] = useState(storageKey);
+    if (loadedKey !== storageKey) {
+        setLoadedKey(storageKey);
+        setScaleRaw(read(storageKey));
     }
     useEffect(() => {
         try {