@ihabdevteam/core 0.321.0 → 0.323.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.d.ts

@@ -1,2 +1,2 @@
 /** 마지막 입력이 키보드였으면 true(모르면 false) */
-export declare function 키보드로눌렀나(): boolean;
+export declare function wasKeyboardPress(): boolean;

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 키보드로눌렀나() {
-    붙이기();
-    return 마지막 === 'keyboard';
+export function wasKeyboardPress() {
+    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/useDeviceManagement.d.ts

@@ -1,5 +1,5 @@
 import type { DeviceForm } from '../types/device';
-type Side = '좌' | '우';
+type Side = 'left' | 'right';
 /**
  * 보청기 기기 등록 / 이력 관리 상태를 캡슐화한 훅.
  */
@@ -11,22 +11,10 @@ export declare function useDeviceManagement(): {
     setShowDevice: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     deviceDirection: Side;
     setDeviceDirection: import("react").Dispatch<import("react").SetStateAction<Side>>;
-    devices: {
-        좌: DeviceForm | null;
-        우: DeviceForm | null;
-    };
-    setDevices: import("react").Dispatch<import("react").SetStateAction<{
-        좌: DeviceForm | null;
-        우: DeviceForm | null;
-    }>>;
-    deviceHistory: {
-        좌: DeviceForm[];
-        우: DeviceForm[];
-    };
-    setDeviceHistory: import("react").Dispatch<import("react").SetStateAction<{
-        좌: DeviceForm[];
-        우: DeviceForm[];
-    }>>;
+    devices: Record<Side, DeviceForm | null>;
+    setDevices: import("react").Dispatch<import("react").SetStateAction<Record<Side, DeviceForm | null>>>;
+    deviceHistory: Record<Side, DeviceForm[]>;
+    setDeviceHistory: import("react").Dispatch<import("react").SetStateAction<Record<Side, DeviceForm[]>>>;
     showDeviceList: boolean;
     setShowDeviceList: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     listForSide: Side;

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

@@ -1,7 +1,17 @@
 'use client';
 import { useCallback, useState } from 'react';
-/** form.direction 이 '좌'·'우' 가 아니면 null — 캐스팅만 하면 devices['엉뚱한값'] 같은 열쇠가 생긴다 */
-const toSide = (d) => (d === '좌' || d === '우' ? d : null);
+/**
+ * `form.direction` 이 `'left'`·`'right'` 가 아니면 null — 캐스팅만 하면 `devices['엉뚱한값']` 같은 열쇠가 생긴다.
+ *
+ * **옛 값(`'좌'`·`'우'`)은 받지 않는다.** 2026-10-13 사장님 결정으로 값을 영어로 옮겼고,
+ * 너그럽게 받는 몫은 **소비자가 진다** — 말귀가 DB 와 오가는 길목 한 자리에 세워 두었다
+ * (`toDbDirection`/`fromDbDirection`). 여기서 함께 받으면 **두 자리가 같은 일을 하고**,
+ * DB 가 다 옮겨진 뒤에도 어느 쪽이 걷혔는지 아무도 모르게 된다.
+ *
+ * 걸리면 **조용히 `null`** 이다 — 터지지도 찍지도 않는다. 옛 값이 그대로 들어오면
+ * 기기가 안 골라지는 꼴로 보이니, 소비자는 **코어에 넘기기 전에** 옮겨 둔다.
+ */
+const toSide = (d) => (d === 'left' || d === 'right' ? d : null);
 /**
  * 보청기 기기 등록 / 이력 관리 상태를 캡슐화한 훅.
  */
@@ -10,15 +20,17 @@ const toSide = (d) => (d === '좌' || d === '우' ? d : null);
  */
 export function useDeviceManagement() {
     const [showDevice, setShowDevice] = useState(false);
-    const [deviceDirection, setDeviceDirection] = useState('좌');
-    const [devices, setDevices] = useState({ 좌: null, 우: null });
-    const [deviceHistory, setDeviceHistory] = useState({ 좌: [], 우: [] });
+    const [deviceDirection, setDeviceDirection] = useState('left');
+    /* 열쇠는 `Side`(= `DeviceSide`) **값**(`'left'`·`'right'`) — 서버의 `side` 열에 오가는 자료다.
+       이름도 값도 영어다 — 값은 2026-10-13 사장님 결정으로 옮겼다(`'좌'`·`'우'` → `'left'`·`'right'`). */
+    const [devices, setDevices] = useState({ left: null, right: null });
+    const [deviceHistory, setDeviceHistory] = useState({ left: [], right: [] });
     const [showDeviceList, setShowDeviceList] = useState(false);
-    const [listForSide, setListForSide] = useState('좌');
+    const [listForSide, setListForSide] = useState('left');
     // form.direction은 각 팝업(DeviceRegistrationPopup의 방향 드롭다운, DeviceListPopup의
-    // 좌/우 탭)에서 사용자가 실제로 고른 값이다 — deviceDirection/listForSide는 팝업을 열 때의
+    // left/right 탭)에서 사용자가 실제로 고른 값이다 — deviceDirection/listForSide는 팝업을 열 때의
     // 초기값일 뿐이라 팝업 내부에서 방향을 바꾸면 더 이상 실제 선택과 일치하지 않는다.
-    // 방향이 비었거나 '좌'·'우' 밖이면 **아무것도 바꾸지 않는다** — 예전에는 검사 없이 캐스팅해
+    // 방향이 비었거나 'left'·'right' 밖이면 **아무것도 바꾸지 않는다** — 예전에는 검사 없이 캐스팅해
     // devices·deviceHistory 에 없는 열쇠가 생겼고 prev[side] 가 undefined 라 이력 펼치기에서 터졌다.
     // 팝업은 닫지 않는다(사용자가 방향을 고르고 다시 제출할 수 있게).
     const handleDeviceSubmit = useCallback((form) => {

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]);
 }