@simplysm/solid 13.0.70 → 13.0.71

package/tests/components/features/permission-table/PermissionTable.spec.tsx

@@ -11,7 +11,7 @@ import type { AppPerm } from "../../../../src/helpers/createAppStructure";
 import { I18nProvider } from "../../../../src/providers/i18n/I18nContext";
 import { ConfigProvider } from "../../../../src/providers/ConfigContext";
 
-// --- 테스트 데이터 ---
+// --- test data ---
 
 const sampleItems: AppPerm[] = [
   {
@@ -32,11 +32,11 @@ const sampleItems: AppPerm[] = [
 ];
 
 // =====================
-// Part 1: 유틸리티 함수 테스트
+// Part 1: utility function tests
 // =====================
 
 describe("collectAllPerms", () => {
-  it("트리에서 모든 고유 perm 타입을 수집한다", () => {
+  it("collects all unique perm types from the tree", () => {
     const result = collectAllPerms(sampleItems);
     expect(result).toContain("use");
     expect(result).toContain("edit");
@@ -44,12 +44,12 @@ describe("collectAllPerms", () => {
     expect(result).toHaveLength(3);
   });
 
-  it("빈 배열은 빈 결과를 반환한다", () => {
+  it("returns empty result for empty array", () => {
     const result = collectAllPerms([]);
     expect(result).toEqual([]);
   });
 
-  it("중첩된 아이템의 perms도 수집한다", () => {
+  it("collects perms from nested items", () => {
     const items: AppPerm[] = [
       {
         title: "루트",
@@ -71,32 +71,32 @@ describe("collectAllPerms", () => {
 });
 
 describe("filterByModules", () => {
-  it("modules가 undefined이면 모든 아이템을 반환한다", () => {
+  it("returns all items when modules is undefined", () => {
     const result = filterByModules(sampleItems, undefined);
     expect(result).toBe(sampleItems);
   });
 
-  it("활성 모듈과 교차가 없는 아이템을 제외한다", () => {
+  it("excludes items with no intersection with active modules", () => {
     const result = filterByModules(sampleItems, ["other"]);
-    // "시스템"은 modules: ["admin"]이므로 "other"와 교차 없음 → 제외
+    // "시스템" has modules: ["admin"], no intersection with "other" → excluded
     const titles = result.map((i) => i.title);
     expect(titles).toContain("사용자 관리");
     expect(titles).not.toContain("시스템");
   });
 
-  it("modules가 없는 아이템은 항상 포함된다", () => {
+  it("always includes items with no modules set", () => {
     const result = filterByModules(sampleItems, ["admin"]);
-    // "사용자 관리"는 modules 미설정 → 항상 포함
+    // "사용자 관리" has no modules set → always included
     const titles = result.map((i) => i.title);
     expect(titles).toContain("사용자 관리");
     expect(titles).toContain("시스템");
   });
 
-  it("자식이 전부 필터링된 그룹 노드(perms 없음)도 제거된다", () => {
+  it("removes group node (no perms) when all children are filtered out", () => {
     const items: AppPerm[] = [
       {
         title: "그룹",
-        // perms 없음 → 그룹 노드
+        // no perms → group node
         children: [
           { title: "항목A", href: "/a", perms: ["use"], modules: ["admin"] },
           { title: "항목B", href: "/b", perms: ["use"], modules: ["admin"] },
@@ -109,19 +109,19 @@ describe("filterByModules", () => {
 });
 
 describe("changePermCheck", () => {
-  it("리프 아이템에 perm을 설정한다", () => {
+  it("sets perm on a leaf item", () => {
     const result = changePermCheck({}, sampleItems[1], "use", true);
     expect(result["/system/use"]).toBe(true);
   });
 
-  it("부모 체크 시 모든 자식이 체크된다 (cascading down)", () => {
+  it("checking parent checks all children (cascading down)", () => {
     const result = changePermCheck({}, sampleItems[0], "use", true);
     expect(result["/user/use"]).toBe(true);
     expect(result["/user/permission/use"]).toBe(true);
     expect(result["/user/list/use"]).toBe(true);
   });
 
-  it("부모 체크 해제 시 모든 자식이 해제된다 (cascading down)", () => {
+  it("unchecking parent unchecks all children (cascading down)", () => {
     const initial: Record<string, boolean> = {
       "/user/use": true,
       "/user/permission/use": true,
@@ -133,7 +133,7 @@ describe("changePermCheck", () => {
     expect(result["/user/list/use"]).toBe(false);
   });
 
-  it("기본 perm(perms[0]) 해제 시 나머지 perms도 해제된다", () => {
+  it("unchecking the base perm (perms[0]) unchecks all other perms", () => {
     const initial: Record<string, boolean> = {
       "/user/use": true,
       "/user/edit": true,
@@ -144,69 +144,69 @@ describe("changePermCheck", () => {
       "/user/list/edit": true,
     };
     const result = changePermCheck(initial, sampleItems[0], "use", false);
-    // 기본 perm "use" 해제 → "edit", "approve"도 해제
+    // unchecking base perm "use" → "edit", "approve" are also unchecked
     expect(result["/user/edit"]).toBe(false);
     expect(result["/user/permission/edit"]).toBe(false);
     expect(result["/user/permission/approve"]).toBe(false);
     expect(result["/user/list/edit"]).toBe(false);
   });
 
-  it("비기본 perm 체크 시 기본 perm이 꺼져있으면 해당 아이템은 건너뛰고 자식에 cascading된다", () => {
-    // 부모(/user)의 기본 perm "use"가 꺼져있으나, 자식들의 "use"는 켜져있음
+  it("checking non-base perm cascades to children, skipping items where base perm is off", () => {
+    // parent (/user) base perm "use" is off, but children's "use" is on
     const initial: Record<string, boolean> = {
       "/user/permission/use": true,
       "/user/list/use": true,
     };
     const result = changePermCheck(initial, sampleItems[0], "edit", true);
-    // 부모(/user): use가 꺼져있으므로 edit 설정 건너뜀
+    // parent (/user): use is off → skip setting edit
     expect(result["/user/edit"]).toBeUndefined();
-    // 자식: use가 켜져있으므로 edit 설정됨
+    // children: use is on → edit is set
     expect(result["/user/permission/edit"]).toBe(true);
     expect(result["/user/list/edit"]).toBe(true);
   });
 });
 
 // =====================
-// Part 2: 컴포넌트 렌더링 테스트
+// Part 2: component rendering tests
 // =====================
 
-describe("PermissionTable 컴포넌트", () => {
+describe("PermissionTable component", () => {
   describe("basic rendering", () => {
-    it("data-permission-table 속성이 있는 div로 렌더링된다", () => {
+    it("renders as DataSheet (div with data-sheet attribute)", () => {
       const { container } = render(() => <PermissionTable items={sampleItems} />);
-      const wrapper = container.querySelector("[data-permission-table]");
+      const wrapper = container.querySelector("[data-sheet]");
       expect(wrapper).toBeTruthy();
       expect(wrapper!.tagName).toBe("DIV");
     });
 
-    it("내부에 DataSheet(table)가 렌더링된다", () => {
+    it("renders a table inside DataSheet", () => {
       const { container } = render(() => <PermissionTable items={sampleItems} />);
       const table = container.querySelector("[data-sheet] table");
       expect(table).toBeTruthy();
     });
 
-    it("헤더에 perm 타입 컬럼이 표시된다", () => {
+    it("displays perm type columns in header", () => {
       const { getByText } = render(() => <PermissionTable items={sampleItems} />);
       expect(getByText("use")).toBeTruthy();
       expect(getByText("edit")).toBeTruthy();
       expect(getByText("approve")).toBeTruthy();
     });
 
-    it("아이템 타이틀이 표시된다", () => {
+    it("displays item titles", () => {
       const { getByText } = render(() => <PermissionTable items={sampleItems} />);
       expect(getByText("사용자 관리")).toBeTruthy();
       expect(getByText("시스템")).toBeTruthy();
     });
 
-    it("자식 아이템이 기본적으로 펼쳐져서 표시된다", () => {
+    it("child items are expanded by default", () => {
       const { getByText } = render(() => <PermissionTable items={sampleItems} />);
       expect(getByText("권한 설정")).toBeTruthy();
       expect(getByText("사용자 목록")).toBeTruthy();
     });
   });
 
-  describe("체크박스 인터랙션", () => {
-    it("체크박스 클릭 시 onValueChange가 호출된다", () => {
+  describe("checkbox interaction", () => {
+    it("clicking a checkbox calls onValueChange", () => {
       const handleChange = vi.fn();
       const { getAllByRole } = render(() => (
         <ConfigProvider clientName="test"><I18nProvider>
@@ -215,12 +215,12 @@ describe("PermissionTable 컴포넌트", () => {
       ));
 
       const checkboxes = getAllByRole("checkbox");
-      // 첫 번째 체크박스를 클릭
+      // click the first checkbox
       fireEvent.click(checkboxes[0]);
       expect(handleChange).toHaveBeenCalled();
     });
 
-    it("controlled 패턴: value prop이 체크박스에 반영된다", () => {
+    it("controlled pattern: value prop is reflected in checkboxes", () => {
       const [value, setValue] = createSignal<Record<string, boolean>>({
         "/system/use": true,
       });
@@ -232,43 +232,43 @@ describe("PermissionTable 컴포넌트", () => {
       ));
 
       const checkboxes = getAllByRole("checkbox");
-      // "시스템"의 "use" 체크박스가 체크되어 있어야 함
+      // "시스템"'s "use" checkbox should be checked
       const checkedBox = checkboxes.find((cb) => cb.getAttribute("aria-checked") === "true");
       expect(checkedBox).toBeTruthy();
     });
   });
 
-  describe("접기/펼치기", () => {
-    it("자식이 있는 아이템의 행에 펼치기/접기 토글이 존재한다", () => {
+  describe("expand/collapse", () => {
+    it("rows with children have an expand/collapse toggle", () => {
       const { getByText } = render(() => <PermissionTable items={sampleItems} />);
-      // "사용자 관리"가 있는 행(tr)을 찾고, 그 행에 expand toggle button이 있는지 확인
+      // find the row containing "사용자 관리" and check for expand toggle button
       const titleEl = getByText("사용자 관리");
       const row = titleEl.closest("tr")!;
       const expandButton = row.querySelector("button");
       expect(expandButton).toBeTruthy();
     });
 
-    it("접기 버튼 클릭 시 자식이 DOM에서 제거된다", () => {
+    it("clicking collapse button removes children from the DOM", () => {
       const { getByText, queryByText } = render(() => <PermissionTable items={sampleItems} />);
 
-      // 초기: 자식 표시 (기본적으로 모두 펼침)
+      // initially: children are visible (all expanded by default)
       expect(getByText("권한 설정")).toBeTruthy();
       expect(getByText("사용자 목록")).toBeTruthy();
 
-      // 접기 버튼 클릭 (사용자 관리 행의 expand toggle)
+      // click collapse button (expand toggle on "사용자 관리" row)
       const titleEl = getByText("사용자 관리");
       const row = titleEl.closest("tr")!;
       const expandButton = row.querySelector("button")!;
       fireEvent.click(expandButton);
 
-      // 자식이 DOM에서 제거됨 (Sheet는 접힌 항목을 렌더링하지 않음)
+      // children are removed from the DOM (Sheet does not render collapsed items)
       expect(queryByText("권한 설정")).toBeNull();
       expect(queryByText("사용자 목록")).toBeNull();
     });
   });
 
-  describe("비활성화", () => {
-    it("disabled prop이 true이면 체크박스 클릭이 무시된다", () => {
+  describe("disabled state", () => {
+    it("checkbox clicks are ignored when disabled prop is true", () => {
       const handleChange = vi.fn();
       const { getAllByRole } = render(() => (
         <ConfigProvider clientName="test"><I18nProvider>

package/tests/components/features/shared-data/SharedDataSelectList.spec.tsx

@@ -430,9 +430,9 @@ describe("SharedDataSelectList", () => {
     });
   });
 
-  // ─── header / modal ────────────────────────────────────
+  // ─── header ────────────────────────────────────────────
 
-  describe("header / modal", () => {
+  describe("header", () => {
     it("header text is displayed when header is provided", () => {
       const accessor = createMockAccessor(["Apple"]);
 
@@ -444,20 +444,5 @@ describe("SharedDataSelectList", () => {
 
       expect(screen.getByText("과일 목록")).toBeTruthy();
     });
-
-    it("management button is displayed when modal is provided", () => {
-      const accessor = createMockAccessor(["Apple"]);
-
-      renderWithDialog(() => (
-        <SharedDataSelectList data={accessor} header="과일" modal={() => <div>Modal</div>} required>
-          <SharedDataSelectList.ItemTemplate>{(item) => <>{item}</>}</SharedDataSelectList.ItemTemplate>
-        </SharedDataSelectList>
-      ));
-
-      // Button is rendered (with IconExternalLink)
-      const headerArea = screen.getByText("과일").parentElement!;
-      const button = headerArea.querySelector("button");
-      expect(button).toBeTruthy();
-    });
   });
 });

package/tests/components/feedback/busy/BusyContainer.spec.tsx

@@ -5,7 +5,7 @@ import { BusyContainer } from "../../../../src/components/feedback/busy/BusyCont
 
 describe("BusyContainer", () => {
   describe("basic rendering", () => {
-    it("children이 표시된다", () => {
+    it("renders children", () => {
       const { getByText } = render(() => (
         <BusyContainer>
           <span>Content</span>
@@ -14,7 +14,7 @@ describe("BusyContainer", () => {
       expect(getByText("Content")).toBeTruthy();
     });
 
-    it("busy가 false이면 오버레이가 표시되지 않는다", () => {
+    it("does not show overlay when busy is false", () => {
       const { container } = render(() => (
         <BusyContainer busy={false}>
           <span>Content</span>
@@ -26,7 +26,7 @@ describe("BusyContainer", () => {
   });
 
   describe("ready prop", () => {
-    it("ready가 false이면 children이 DOM에서 제거된다", () => {
+    it("removes children from DOM when ready is false", () => {
       const { queryByText } = render(() => (
         <BusyContainer ready={false}>
           <span>Content</span>
@@ -35,7 +35,7 @@ describe("BusyContainer", () => {
       expect(queryByText("Content")).toBeNull();
     });
 
-    it("ready가 true이면 children이 표시된다", () => {
+    it("shows children when ready is true", () => {
       const { getByText } = render(() => (
         <BusyContainer ready={true}>
           <span>Content</span>
@@ -44,7 +44,7 @@ describe("BusyContainer", () => {
       expect(getByText("Content")).toBeTruthy();
     });
 
-    it("ready가 undefined이면 children이 표시된다", () => {
+    it("shows children when ready is undefined", () => {
       const { getByText } = render(() => (
         <BusyContainer>
           <span>Content</span>
@@ -53,7 +53,7 @@ describe("BusyContainer", () => {
       expect(getByText("Content")).toBeTruthy();
     });
 
-    it("ready가 false이면 오버레이가 마운트된다", async () => {
+    it("mounts overlay when ready is false", async () => {
       const { container } = render(() => (
         <BusyContainer ready={false}>
           <span>Content</span>
@@ -65,7 +65,7 @@ describe("BusyContainer", () => {
       expect(overlay).toBeTruthy();
     });
 
-    it("ready가 false에서 true로 변경되면 children이 다시 표시된다", () => {
+    it("shows children again when ready changes from false to true", () => {
       const [ready, setReady] = createSignal(false);
       const { queryByText } = render(() => (
         <BusyContainer ready={ready()}>

package/tests/components/feedback/notification/NotificationBell.spec.tsx

@@ -15,7 +15,7 @@ describe("NotificationBell", () => {
     vi.unstubAllGlobals();
   });
 
-  it("버튼이 렌더링된다", () => {
+  it("renders button", () => {
     const { container } = render(() => (
       <ConfigContext.Provider value={{ clientName: "testApp" }}>
         <NotificationProvider>
@@ -27,7 +27,7 @@ describe("NotificationBell", () => {
     expect(container.querySelector("[data-notification-bell]")).not.toBeNull();
   });
 
-  it("알림이 없으면 뱃지가 표시되지 않는다", () => {
+  it("does not show badge when there are no notifications", () => {
     render(() => (
       <ConfigContext.Provider value={{ clientName: "testApp" }}>
         <NotificationProvider>
@@ -40,7 +40,7 @@ describe("NotificationBell", () => {
     expect(badge).toBeNull();
   });
 
-  it("알림이 있으면 뱃지에 개수가 표시된다", async () => {
+  it("shows count on badge when notifications are present", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (
@@ -64,7 +64,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("버튼 클릭 시 Dropdown이 열린다", async () => {
+  it("opens Dropdown on button click", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (
@@ -90,7 +90,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("Dropdown에 알림 목록이 표시된다", async () => {
+  it("shows notification list in Dropdown", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (
@@ -118,7 +118,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("aria-label에 알림 개수가 포함된다", async () => {
+  it("includes notification count in aria-label", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (
@@ -141,7 +141,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("aria-haspopup과 aria-expanded가 올바르게 설정된다", async () => {
+  it("sets aria-haspopup and aria-expanded correctly", async () => {
     render(() => (
       <ConfigContext.Provider value={{ clientName: "testApp" }}>
         <NotificationProvider>
@@ -161,7 +161,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("드롭다운 열면 모든 알림이 읽음 처리된다", async () => {
+  it("marks all notifications as read when dropdown opens", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (
@@ -191,7 +191,7 @@ describe("NotificationBell", () => {
     });
   });
 
-  it("전체 삭제 버튼 클릭 시 clear가 호출된다", async () => {
+  it("calls clear when clear-all button is clicked", async () => {
     let notification: ReturnType<typeof useNotification>;
 
     render(() => (

package/tests/components/feedback/print/Print.spec.tsx

@@ -2,7 +2,7 @@ import { render } from "@solidjs/testing-library";
 import { describe, it, expect } from "vitest";
 import { Print } from "../../../../src/components/feedback/print/Print";
 
-describe("Print 컴포넌트", () => {
+describe("Print", () => {
   describe("basic rendering", () => {
     it("renders children", () => {
       const { getByText } = render(() => <Print>테스트 내용</Print>);
@@ -11,7 +11,7 @@ describe("Print 컴포넌트", () => {
   });
 
   describe("Print.Page", () => {
-    it("data-print-page 속성이 렌더링된다", () => {
+    it("renders with data-print-page attribute", () => {
       const { container } = render(() => (
         <Print>
           <Print.Page>페이지 1</Print.Page>
@@ -21,7 +21,7 @@ describe("Print 컴포넌트", () => {
       expect(page).toBeTruthy();
     });
 
-    it("여러 Print.Page가 각각 data-print-page를 가진다", () => {
+    it("each Print.Page has data-print-page attribute", () => {
       const { container } = render(() => (
         <Print>
           <Print.Page>페이지 1</Print.Page>
@@ -33,7 +33,7 @@ describe("Print 컴포넌트", () => {
       expect(pages.length).toBe(3);
     });
 
-    it("Print.Page children이 렌더링된다", () => {
+    it("renders Print.Page children", () => {
       const { getByText } = render(() => (
         <Print>
           <Print.Page>페이지 내용</Print.Page>

package/tests/components/form-control/Button.spec.tsx

@@ -2,23 +2,23 @@ import { render, fireEvent } from "@solidjs/testing-library";
 import { describe, it, expect, vi } from "vitest";
 import { Button } from "../../../src/components/form-control/Button";
 
-describe("Button 컴포넌트", () => {
+describe("Button component", () => {
   describe("basic rendering", () => {
-    it("children이 버튼 내부에 표시된다", () => {
+    it("renders children inside the button", () => {
       const { getByRole } = render(() => <Button>Click Me</Button>);
       const button = getByRole("button");
 
       expect(button.textContent).toBe("Click Me");
     });
 
-    it("type 속성 기본값은 button이다", () => {
+    it("defaults type to button", () => {
       const { getByRole } = render(() => <Button>Click</Button>);
       const button = getByRole("button");
 
       expect(button.getAttribute("type")).toBe("button");
     });
 
-    it("type 속성을 submit으로 오버라이드할 수 있다", () => {
+    it("overrides type with submit", () => {
       const { getByRole } = render(() => <Button type="submit">Submit</Button>);
       const button = getByRole("button");
 
@@ -26,8 +26,8 @@ describe("Button 컴포넌트", () => {
     });
   });
 
-  describe("theme 속성", () => {
-    it("theme prop에 따라 스타일이 달라진다", () => {
+  describe("theme prop", () => {
+    it("applies different styles per theme", () => {
       const { getByRole: getDefault } = render(() => <Button>Click</Button>);
       const { getByRole: getThemed } = render(() => <Button theme="danger">Click</Button>);
 
@@ -35,8 +35,8 @@ describe("Button 컴포넌트", () => {
     });
   });
 
-  describe("variant 속성", () => {
-    it("variant prop에 따라 스타일이 달라진다", () => {
+  describe("variant prop", () => {
+    it("applies different styles per variant", () => {
       const { getByRole: getOutline } = render(() => <Button>Click</Button>);
       const { getByRole: getSolid } = render(() => <Button variant="solid">Click</Button>);
       const { getByRole: getGhost } = render(() => <Button variant="ghost">Click</Button>);
@@ -51,8 +51,8 @@ describe("Button 컴포넌트", () => {
     });
   });
 
-  describe("size 속성", () => {
-    it("size prop에 따라 스타일이 달라진다", () => {
+  describe("size prop", () => {
+    it("applies different styles per size", () => {
       const { getByRole: getDefault } = render(() => <Button>Click</Button>);
       const { getByRole: getSm } = render(() => <Button size="sm">Click</Button>);
       const { getByRole: getLg } = render(() => <Button size="lg">Click</Button>);
@@ -67,8 +67,8 @@ describe("Button 컴포넌트", () => {
     });
   });
 
-  describe("inset 속성", () => {
-    it("inset prop에 따라 스타일이 달라진다", () => {
+  describe("inset prop", () => {
+    it("applies different styles when inset", () => {
       const { getByRole: getDefault } = render(() => <Button>Click</Button>);
       const { getByRole: getInset } = render(() => <Button inset>Click</Button>);
 
@@ -76,23 +76,23 @@ describe("Button 컴포넌트", () => {
     });
   });
 
-  describe("disabled 속성", () => {
-    it("disabled prop에 따라 스타일이 달라진다", () => {
+  describe("disabled prop", () => {
+    it("applies different styles when disabled", () => {
       const { getByRole: getDefault } = render(() => <Button>Click</Button>);
       const { getByRole: getDisabled } = render(() => <Button disabled>Click</Button>);
 
       expect(getDefault("button").className).not.toBe(getDisabled("button").className);
     });
 
-    it("disabled=true일 때 HTML disabled 속성이 설정된다", () => {
+    it("sets HTML disabled attribute when disabled=true", () => {
       const { getByRole } = render(() => <Button disabled>Click</Button>);
 
       expect(getByRole("button").hasAttribute("disabled")).toBe(true);
     });
   });
 
-  describe("이벤트 핸들링", () => {
-    it("onClick handler가 버튼 클릭 시 호출된다", () => {
+  describe("event handling", () => {
+    it("calls onClick handler on click", () => {
       const handleClick = vi.fn();
       const { getByRole } = render(() => <Button onClick={handleClick}>Click</Button>);
 
@@ -101,7 +101,7 @@ describe("Button 컴포넌트", () => {
       expect(handleClick).toHaveBeenCalledTimes(1);
     });
 
-    it("disabled 상태에서는 클릭이 차단된다", () => {
+    it("blocks click when disabled", () => {
       const { getByRole } = render(() => <Button disabled>Click</Button>);
 
       expect(getByRole("button").hasAttribute("disabled")).toBe(true);