sonamu 0.7.21 → 0.7.23

package/dist/template/implementations/view_list.template.js

@@ -1,19 +1,16 @@
-import assert from "assert";
 import inflection from "inflection";
-import { flat, unique } from "radashi";
+import { flat } from "radashi";
 import { z } from "zod";
 import { EntityManager } from "../../entity/entity-manager.js";
-import { getColumnsNode } from "../entity-converter.js";
 import { getEnumInfoFromColName, getRelationPropFromColName } from "../helpers.js";
 import { Template } from "../template.js";
-import { getZodTypeById, zodTypeToRenderingNode } from "../zod-converter.js";
 export class Template__view_list extends Template {
     constructor(){
         super("view_list");
     }
     getTargetAndPath(names) {
         return {
-            target: "web/src/pages/admin",
+            target: "web/src/routes/admin",
             path: `${names.fsPlural}/index.tsx`
         };
     }
@@ -21,7 +18,17 @@ export class Template__view_list extends Template {
         return `<Table.Cell key="${key}"${collapsing ? " collapsing" : ""}${className ? ` className={\`${className}\`}` : ""}>${body}</Table.Cell>`;
     }
     renderColumn(entityId, col, names, parentObj = "row", withoutName = false) {
-        const colName = withoutName ? `${parentObj}` : `${parentObj}.${col.name}`;
+        // 중첩 경로 처리 (예: "user.name" -> "row.user?.name")
+        let colName;
+        if (withoutName) {
+            colName = parentObj;
+        } else if (col.name.includes(".")) {
+            // 중첩 경로는 optional chaining으로 변환
+            const parts = col.name.split(".");
+            colName = `${parentObj}.${parts.join("?.")}`;
+        } else {
+            colName = `${parentObj}.${col.name}`;
+        }
         switch(col.renderType){
             case "string-plain":
             case "string-date":
@@ -29,36 +36,45 @@ export class Template__view_list extends Template {
                 return `<>{${colName}}</>`;
             case "number-fk_id":
                 {
-                    const relPropFk = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
-                    return `<>${relPropFk.with}#{${colName}}</>`;
+                    try {
+                        const baseName = col.name.includes(".") ? (col.name.split(".").pop() ?? col.name).replace("_id", "") : col.name.replace("_id", "");
+                        const relPropFk = getRelationPropFromColName(entityId, baseName);
+                        return `<>${relPropFk.with}#{${colName}}</>`;
+                    } catch  {
+                        return `<>{${colName}}</>`;
+                    }
                 }
             case "string-image":
-                return `<>{${col.nullable ? `${colName} && ` : ""}<img src={${colName}} />}</>`;
+                return `<>{${col.nullable ? `${colName} && ` : ""}<img src={${colName}} alt="${col.label ?? col.name}" className="h-8 w-8 object-cover rounded" />}</>`;
             case "datetime":
-                if (col.nullable) {
-                    return `<span className="text-tiny">{${colName} === null ? '-' : formatDateTime(${colName})}</span>`;
+                if (col.nullable || col.name.includes(".")) {
+                    return `<span>{${colName} ? datetimeF(${colName}) : '-'}</span>`;
                 } else {
-                    return `<span className="text-tiny">{formatDateTime(${colName})}</span>`;
+                    return `<span>{datetimeF(${colName})}</span>`;
                 }
             case "string-datetime":
-                if (col.nullable) {
-                    return `<span className="text-tiny">{${colName} === null ? '-' : dateF(${colName})}</span>`;
+                if (col.nullable || col.name.includes(".")) {
+                    return `<span>{${colName} ? dateF(${colName}) : '-'}</span>`;
                 } else {
-                    return `<span className="text-tiny">{dateF(${colName})}</span>`;
+                    return `<span>{dateF(${colName})}</span>`;
                 }
             case "boolean":
-                return `<>{${colName} ? <Label color='green' circular>O</Label> : <Label color='grey' circular>X</Label> }</>`;
+                return `<>{${colName} ? <Badge variant="default">O</Badge> : <Badge variant="secondary">X</Badge>}</>`;
             case "enums":
                 {
-                    const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
-                    return `<>{${col.nullable ? `${colName} && ` : ""}${enumId}Label[${colName}]}</>`;
+                    try {
+                        const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
+                        return `<>{${col.nullable ? `${colName} && ` : ""}${enumId}Label[${colName}]}</>`;
+                    } catch  {
+                        return `<>{${colName}}</>`;
+                    }
                 }
             case "array-images":
-                return `<>{ ${colName}.map(r => ${col.nullable ? `r && ` : ""}<img src={r} />) }</>`;
+                return `<div className="flex gap-1">{ ${colName}?.map((r, i) => ${col.nullable ? `r && ` : ""}<img key={i} src={r} alt={\`${col.label ?? col.name} \${i + 1}\`} className="h-8 w-8 object-cover rounded" />) }</div>`;
             case "number-plain":
-                return `<>{${col.nullable ? `${colName} && ` : ""}numF(${colName})}</>`;
+                return `<>{${col.nullable || col.name.includes(".") ? `${colName} && ` : ""}numF(${colName})}</>`;
             case "object":
-                return `<>{/* object ${colName} */}</>`;
+                return `<span className="text-xs">{${col.nullable ? `${colName} ? ` : ""}JSON.stringify(${colName})${col.nullable ? ` : '-'` : ""}}</span>`;
             case "object-pick":
                 {
                     const pickedChild = col.children?.find((child)=>child.name === col.config?.picked);
@@ -85,19 +101,21 @@ export class Template__view_list extends Template {
         } else if (col.renderType === "object") {
             try {
                 const relProp = getRelationPropFromColName(entityId, col.name);
-                const result = col.children?.map((child)=>{
+                const result = (col.children ?? []).map((child)=>{
                     entityId = relProp.with;
                     names = EntityManager.getNamesFromId(relProp.with);
                     return this.renderColumnImport(entityId, child, names);
                 });
-                return flat(result ?? []);
+                return flat(result);
             } catch  {
                 return [
                     null
                 ];
             }
         } else if (col.renderType === "array") {
-            assert(col.element);
+            if (!col.element) return [
+                null
+            ];
             return this.renderColumnImport(entityId, col.element, names);
         }
         return [
@@ -165,32 +183,41 @@ export class Template__view_list extends Template {
     }
     getDefault(columns) {
         const def = {
-            orderBy: "id-desc",
-            search: "title"
+            orderBy: "",
+            search: "",
+            hasSearch: false,
+            hasOrderBy: false
         };
         const orderByZodType = columns.find((col)=>col.name === "orderBy")?.zodType;
         if (orderByZodType && orderByZodType instanceof z.ZodEnum) {
-            def.orderBy = orderByZodType.options[0].toString();
+            def.orderBy = Object.keys(orderByZodType.enum)[0];
+            def.hasOrderBy = true;
         }
         const searchZodType = columns.find((col)=>col.name === "search")?.zodType;
         if (searchZodType && searchZodType instanceof z.ZodEnum) {
-            def.search = searchZodType.options[0].toString();
+            def.search = Object.keys(searchZodType.enum)[0];
+            def.hasSearch = true;
         }
         return def;
     }
     async render({ entityId }) {
+        const { getColumnsNode } = await import("../entity-converter.js");
+        const { getZodTypeById, zodTypeToRenderingNode } = await import("../zod-converter.js");
         const columnsNode = await getColumnsNode(entityId, "A");
         const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);
         const listParamsNode = zodTypeToRenderingNode(listParamsZodType);
         const names = EntityManager.getNamesFromId(entityId);
         const entity = EntityManager.get(entityId);
         // 실제 리스트 컬럼
-        const columns = columnsNode.children.filter((col)=>col.name !== "id").map((col)=>{
+        const columns = columnsNode.children.sort((a, b)=>a.name === "id" ? -1 : b.name === "id" ? 1 : 0).map((col)=>{
             const propCandidate = entity.props.find((p)=>p.name === col.name);
+            const rendered = this.renderColumn(entityId, col, names);
             return {
                 name: col.name,
-                label: propCandidate?.desc ?? col.label,
-                tc: `(row) => ${this.renderColumn(entityId, col, names)}`
+                label: col.name === "id" ? "ID" : propCandidate?.desc ?? col.label,
+                tc: `(row) => ${rendered}`,
+                fit: col.renderType === "number-id" || col.renderType === "datetime" || col.renderType === "string-datetime",
+                align: col.renderType === "number-id" ? "center" : undefined
             };
         });
         // 필터 컬럼
@@ -209,17 +236,23 @@ export class Template__view_list extends Template {
             let enumId;
             if (col.renderType === "enums") {
                 if (col.name === "search") {
-                    key = "view_enums_dropdown";
+                    key = "view_enums_select";
                     enumId = `${names.capital}SearchField`;
                     targetEntityId = names.capital;
                 } else {
                     key = "view_enums_select";
-                    try {
-                        const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);
-                        targetEntityId = targetEntityNames.capital;
-                        enumId = id;
-                    } catch  {
-                        continue;
+                    // config.enumId 우선 사용
+                    if (col.config && "enumId" in col.config) {
+                        enumId = col.config.enumId;
+                        targetEntityId = entityId;
+                    } else {
+                        try {
+                            const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);
+                            targetEntityId = targetEntityNames.capital;
+                            enumId = id;
+                        } catch  {
+                            continue;
+                        }
                     }
                 }
             } else {
@@ -239,232 +272,364 @@ export class Template__view_list extends Template {
                 }
             });
         }
-        // 리스트 컬럼
-        assert(columnsNode.children);
-        const columnImports = unique(columnsNode.children.flatMap((col)=>{
-            return this.renderColumnImport(entityId, col, names);
-        }).filter((col)=>col !== null)).join("\n");
+        // 컬럼에서 사용하는 enum들 수집
+        const columnEnums = [];
+        (columnsNode.children ?? []).forEach((col)=>{
+            if (col.renderType === "enums") {
+                try {
+                    const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
+                    columnEnums.push(enumId);
+                } catch  {}
+            }
+        });
         // SearchInput
-        assert(preTemplates);
-        preTemplates.push({
+        preTemplates?.push({
             key: "view_search_input",
             options: {
                 entityId
             }
         });
         // 디폴트 파라미터
-        const def = this.getDefault(filterColumns);
+        // const def = this.getDefault(filterColumns);
         return {
             ...this.getTargetAndPath(names),
             body: `
-import React from 'react';
-import { Link } from 'react-router-dom';
-import {
-  Breadcrumb,
-  Checkbox,
-  Pagination,
-  Segment,
-  Table,
-  TableRow,
-  Message,
-  Transition,
-  Button,
-  Label,
-} from 'semantic-ui-react';
-import classNames from 'classnames';
-import { DateTime } from "luxon";
-import { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, formatDate, formatDateTime } from '@sonamu-kit/react-sui';
+import { useState, Fragment } from "react";
+import { createFileRoute, useNavigate } from "@tanstack/react-router";
+
+import { Card, CardContent, CardHeader } from "@sonamu-kit/react-components/components";
+import { Badge } from "@sonamu-kit/react-components/components";
+import { Button } from "@sonamu-kit/react-components/components";
+import { Pagination, Table, TableBody, TableCell, type TableCol, TableHead, TableHeader, TableRow } from "@sonamu-kit/react-components/components";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@sonamu-kit/react-components/components";
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle } from "@sonamu-kit/react-components/components";
+import { Input } from "@sonamu-kit/react-components/components";
+import { Checkbox } from "@sonamu-kit/react-components/components";
 
+import { useListParams, numF, dateF, datetimeF } from "@sonamu-kit/react-components/lib";
 import { ${names.capital}SubsetA } from "@/services/sonamu.generated";
-import { ${names.capital}Service } from '@/services/services.generated';
-import { ${names.capital}ListParams } from '@/services/${names.fs}/${names.fs}.types';
-${columnImports}
-${filterColumns.map((col)=>{
-                return this.renderFilterImport(entityId, col, names);
-            }).join("\n")}
+import { ${names.capital}Service } from "@/services/services.generated";
+import { ${names.capital}ListParams } from "@/services/${names.fs}/${names.fs}.types";
+import { ${(()=>{
+                // 기본 enum 수집 (filterColumns에 있는 것만)
+                const baseEnums = [];
+                if (filterColumns.some((col)=>col.name === "orderBy")) {
+                    baseEnums.push(`${names.capital}OrderBy`, `${names.capital}OrderByLabel`);
+                }
+                if (filterColumns.some((col)=>col.name === "search")) {
+                    baseEnums.push(`${names.capital}SearchField`, `${names.capital}SearchFieldLabel`);
+                }
+                // 필터 enum 수집 (config.enumId 우선, 없으면 getEnumInfoFromColName)
+                const filterEnumIds = filterColumns.filter((col)=>col.renderType === "enums" && col.name !== "search" && col.name !== "orderBy").map((col)=>{
+                    if (col.config && "enumId" in col.config) {
+                        return col.config.enumId;
+                    }
+                    try {
+                        const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
+                        return enumId;
+                    } catch  {
+                        return null;
+                    }
+                }).filter(Boolean);
+                // 모든 enum 합치고 중복 제거
+                const allEnums = [
+                    ...new Set([
+                        ...filterEnumIds,
+                        ...columnEnums
+                    ])
+                ];
+                const enumImports = allEnums.flatMap((enumId)=>[
+                        `${enumId}`,
+                        `${enumId}Label`
+                    ]);
+                return [
+                    ...baseEnums,
+                    ...enumImports
+                ].join(", ");
+            })()} } from "@/services/sonamu.generated";
+${(()=>{
+                // FK 필드의 AsyncSelect 컴포넌트 import
+                const fkColumns = filterColumns.filter((col)=>col.name.endsWith("_id") && col.name !== "id");
+                return fkColumns.map((col)=>{
+                    try {
+                        const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                        const targetNames = EntityManager.getNamesFromId(relProp.with);
+                        return `import { ${relProp.with}IdAsyncSelect } from "@/components/${targetNames.fs}/${relProp.with}IdAsyncSelect";`;
+                    } catch  {
+                        return "";
+                    }
+                }).filter(Boolean).join("\n");
+            })()}
+${filterColumns.some((col)=>col.name === "search") ? `
+import { ${names.capital}SearchFieldSelect } from "@/components/${names.fs}/${names.capital}SearchFieldSelect";` : ""}
+${filterColumns.some((col)=>col.name === "orderBy") ? `
+import { ${names.capital}OrderBySelect } from "@/components/${names.fs}/${names.capital}OrderBySelect";` : ""}
+
+import EditIcon from "~icons/lucide/square-pen";
+import TrashIcon from "~icons/lucide/trash-2";
+import ListIcon from "~icons/mdi/format-list-bulleted";
+import SearchIcon from "~icons/mdi/magnify";
+
+export const Route = createFileRoute("/admin/${names.fsPlural}/")({\n  head: () => ({\n    meta: [\n      { title: "${entity.title ?? names.capital} List" },\n      { name: "description", content: "${entity.title ?? names.capital} 목록 관리" },\n    ],\n  }),\n  component: ${names.capital}List,\n});\n\ntype ${names.capital}ListProps = {};
+
+function ${names.capital}List({}: ${names.capital}ListProps) {
+  const navigate = useNavigate();
+
+  // 상태 관리
+  const [selectedItems, setSelectedItems] = useState<Set<number>>(new Set());
+  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+  const [itemToDelete, setItemToDelete] = useState<{ id: number; name?: string } | null>(null);
 
-type ${names.capital}ListProps = {};
-export default function ${names.capital}List({}: ${names.capital}ListProps) {
   // 리스트 필터
   const { listParams, register } = useListParams(${names.capital}ListParams, {
-    num: 12,
+    num: 10,
     page: 1,
-    orderBy: '${def.orderBy}',
-    search: '${def.search}',
+    keyword: "",${filterColumns.some((col)=>col.name === "search") ? `
+    search: ${names.capital}SearchField.options[0],` : ""}${filterColumns.some((col)=>col.name === "orderBy") ? `
+    orderBy: ${names.capital}OrderBy.options[0],` : ""}
   });
 
   // 리스트 쿼리
-  const { data, refetch, isLoading } = ${names.capital}Service.use${names.capitalPlural}('A', listParams);
+  const { data, refetch, isLoading } = ${names.capital}Service.use${names.capitalPlural}("A", listParams);
   const { rows, total } = data ?? {};
 
-  // 삭제
-  const confirmDel = (ids: number[]) => {
-    const answer = confirm('삭제하시겠습니까?');
-    if (!answer) {
-      return;
-    }
-
-    ${names.capital}Service.del(ids).then(() => {
-      refetch();
-    });
+  // 현재 경로와 타이틀
+  const PAGE = {
+    route: "/admin/${names.fsPlural}",
+    title: "${entity.title ?? names.capital}",
   };
 
-  // 일괄 삭제
-  const confirmDelSelected = () => {
-    const answer = confirm(\`\${selectedKeys.length}건을 일괄 삭제하시겠습니까?\`);
-    if (!answer) {
-      return;
+  // 컬럼 정의
+  type ${names.capital}Row = NonNullable<typeof rows>[number];
+  const columns: TableCol<${names.capital}Row>[] = [
+${columns.map((col)=>`    {
+      label: "${col.label}",
+      tc: ${col.tc},${col.fit ? `
+      fit: true,` : ""}${col.align ? `
+      align: "${col.align}",` : ""}
+    }`).join(",\n")},
+    {
+      label: "Manage",
+      fit: true,
+      align: "center",
+      tc: (row) => (
+        <div className="flex items-center justify-center gap-1">
+          <Button
+            variant="yellow"
+            size="xs"
+            icon={<EditIcon />}
+            onClick={() => navigate({ to: \`\${PAGE.route}/form\`, search: { id: row.id } })}
+          />
+          <Button
+            variant="red"
+            size="xs"
+            icon={<TrashIcon />}
+            onClick={() => handleDeleteClick(row.id)}
+          />
+        </div>
+      ),
+    },
+  ];
+
+  // 선택 핸들러
+  const handleToggleItem = (id: number) => {
+    const newSelection = new Set(selectedItems);
+    if (newSelection.has(id)) {
+      newSelection.delete(id);
+    } else {
+      newSelection.add(id);
     }
+    setSelectedItems(newSelection);
+  };
 
-    ${names.capital}Service.del(selectedKeys).then(() => {
-      refetch();
-    });
+  const isAllSelected = () => {
+    return (rows?.length ?? 0) > 0 && rows!.every((row) => selectedItems.has(row.id));
   };
 
-  // 현재 경로와 타이틀
-  const PAGE = {
-    route: '/admin/${names.fsPlural}',
-    title: '${entity.title ?? names.capital}',
+  const handleSelectAll = (checked: boolean) => {
+    if (checked) {
+      setSelectedItems(new Set(rows?.map((row) => row.id) ?? []));
+    } else {
+      setSelectedItems(new Set());
+    }
   };
 
-  // 선택
-  const {
-    getSelected,
-    isAllSelected,
-    selectedKeys,
-    toggle,
-    selectAll,
-    deselectAll,
-    handleCheckboxClick,
-  } = useSelection((rows ?? []).map((row) => row.id));
+  // 삭제 핸들러
+  const handleDeleteClick = (id: number, name?: string) => {
+    setItemToDelete({ id, name });
+    setDeleteDialogOpen(true);
+  };
 
-  // 컬럼
-  const columns:SonamuCol<${names.capital}SubsetA>[] = [${columns.map((col)=>{
-                return [
-                    `{ label: "${col.label}",`,
-                    `tc: ${col.tc}, `,
-                    `collapsing: ${[
-                        "Title",
-                        "Name"
-                    ].includes(col.label) === false}, }`
-                ].join("\n");
-            }).join(",\n")}];
+  const handleConfirmDelete = () => {
+    if (itemToDelete) {
+      ${names.capital}Service.del([itemToDelete.id]).then(() => {
+        refetch();
+      });
+    }
+    setDeleteDialogOpen(false);
+    setItemToDelete(null);
+  };
 
   return (
-    <div className="list ${names.fsPlural}-index">
-      <div className="top-nav">
-        <div className="header-row">
-          <div className="header">{PAGE.title}</div>
-          <AppBreadcrumbs>
-            <Breadcrumb.Section active>{PAGE.title}</Breadcrumb.Section>
-          </AppBreadcrumbs>
-          <${names.capital}SearchInput
-            input={register('keyword')}
-            dropdown={register('search')}
-          />
-        </div>
-        <div className="filters-row">
-          ${filterColumns.map((col)=>{
-                return this.renderFilter(entityId, col, names);
-            }).join("&nbsp;\n")}
-        </div>
-      </div>
-
-      <Segment basic padded className="contents-segment" loading={isLoading}>
-        <div className="buttons-row">
-          <div className={classNames('count', { hidden: isLoading })}>
-            {total} 건
-          </div>
-          <div className="buttons">
-            <AddButton currentRoute={PAGE.route} icon="write" label="추가" />
+    <div className="flex-1 overflow-auto">
+      <div className="max-w-[1800px] mx-auto p-8">
+        <div className="space-y-6 mb-8">
+          {/* Header */}
+          <div className="flex items-center gap-2">
+            <ListIcon className="h-5 w-5" />
+            <span className="text-lg font-semibold h-5">{PAGE.title}</span>
           </div>
-        </div>
 
-        <Table
-          celled
-          compact
-          selectable
-          className={classNames({ hidden: total === undefined || total === 0 })}
-        >
-          <Table.Header>
-            <TableRow>
-              <Table.HeaderCell collapsing>
-                <Checkbox
-                  label="ID"
-                  checked={isAllSelected}
-                  onChange={isAllSelected ? deselectAll : selectAll}
-                />
-              </Table.HeaderCell>
-              {
-                /* Header */
-                columns.map((col, index) => col.th ?? <Table.HeaderCell key={index} collapsing={col.collapsing}>{ col.label }</Table.HeaderCell>)
-              }
-              <Table.HeaderCell>관리</Table.HeaderCell>
-            </TableRow>
-          </Table.Header>
-          <Table.Body>
-            {rows &&
-              rows.map((row, rowIndex) => (
-                <Table.Row key={row.id}>
-                  <Table.Cell>
-                    <Checkbox
-                      label={row.id}
-                      checked={getSelected(row.id)}
-                      onChange={() => toggle(row.id)}
-                      onClick={(e) =>
-                        handleCheckboxClick(e, rowIndex)
-                      }
+          <Card className="shadow-sm border-border/40 overflow-hidden">
+            <CardHeader className="pb-0 px-0 pt-0">
+              {/* Filters */}
+              <div className="bg-gray-100 px-6 py-4 space-y-3">
+                <div className="flex items-center gap-3 flex-wrap">
+${filterColumns.some((col)=>col.name === "search") ? `                  <${names.capital}SearchFieldSelect
+                    {...register("search")}
+                    placeholder="Search Type"
+                    className="w-[200px] h-8 bg-white border-gray-300 text-xs"
+                  />` : ""}
+
+                  <div className="relative flex-1 max-w-xs">
+                    <Input
+                      {...register("keyword")}
+                      placeholder="Search..."
+                      className="h-8 pr-8 text-xs bg-white border-gray-300"
                     />
-                  </Table.Cell>
-                  {
-                    /* Body */
-                    columns.map((col, colIndex) => (
-                      <Table.Cell key={colIndex} collapsing={col.collapsing} className={col.className}>
-                        {col.tc(row, rowIndex)}
-                      </Table.Cell>
-                    ))
-                  }
-                  <Table.Cell collapsing>
-                    <EditButton
-                      as={Link}
-                      to={\`\${PAGE.route}/form?id=\${row.id}\`}
-                      state={{ from: PAGE.route }}
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      icon={<SearchIcon />}
+                      className="absolute right-0 top-0 h-8 w-8 hover:bg-transparent"
                     />
-                    <DelButton onClick={() => confirmDel([row.id])} />
-                  </Table.Cell>
-                </Table.Row>
-              ))}
-          </Table.Body>
-        </Table>
-        <div
-          className={classNames('pagination-row', {
-            hidden: (total ?? 0) === 0,
-          })}
-        >
-          <Pagination
-            totalPages={Math.ceil((total ?? 0) / (listParams.num ?? 24))}
-            {...register('page')}
-          />
-        </div>
-      </Segment>
+                  </div>
+
+                  <div className="ml-auto">
+                    <Button
+                      className="h-8 px-4 bg-primary hover:bg-primary/90 text-white"
+                      onClick={() => navigate({ to: \`\${PAGE.route}/form\` })}
+                    >
+                      <span className="text-xs">Create</span>
+                    </Button>
+                  </div>
+                </div>
+
+                <div className="flex items-center gap-3 flex-wrap">
+${filterColumns.filter((col)=>col.name !== "search" && col.name !== "orderBy").map((col)=>{
+                if (col.renderType === "enums") {
+                    try {
+                        // config.enumId가 있으면 우선 사용, 없으면 getEnumInfoFromColName 시도
+                        const enumId = col.config && "enumId" in col.config ? col.config.enumId : getEnumInfoFromColName(entityId, col.name).id;
+                        return `                  <Select key={\`${col.name}-\${listParams.${col.name}}\`} {...register("${col.name}")} clearable>
+                    <SelectTrigger className="w-[200px] h-8 bg-white border-gray-300 text-xs">
+                      <SelectValue placeholder="${col.label}" className="truncate" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {${enumId}.options.map((key) => (
+                        <SelectItem key={key} value={key}>
+                          {${enumId}Label[key]}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>`;
+                    } catch  {
+                        return "";
+                    }
+                }
+                // FK 필드 (AsyncSelect)
+                if (col.name.endsWith("_id") && col.name !== "id") {
+                    try {
+                        const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                        return `                  <${relProp.with}IdAsyncSelect
+                    subset="A"
+                    {...register("${col.name}")}
+                    placeholder="${col.label ?? relProp.with}"
+                    clearable
+                    className="w-[200px] h-8 text-xs"
+                  />`;
+                    } catch  {
+                        return "";
+                    }
+                }
+                return "";
+            }).filter(Boolean).join("\n")}
+${filterColumns.some((col)=>col.name === "orderBy") ? `                  <${names.capital}OrderBySelect
+                    {...register("orderBy")}
+                    placeholder="Sort"
+                    textPrefix="Sort: "
+                    className="w-[200px] h-8 bg-white border-gray-300 text-xs"
+                  />` : ""}
+                  <span className="text-xs text-muted-foreground">{total ?? 0} results</span>
+                </div>
+              </div>
+            </CardHeader>
+
+            <CardContent className="px-6 pb-6 pt-6 bg-white">
+              {/* Table */}
+              <Table>
+                <TableHeader>
+                  <TableRow className="hover:bg-transparent bg-gray-100">
+                    <TableHead className="h-9 text-xs w-[40px]">
+                      <Checkbox
+                        checked={isAllSelected()}
+                        onValueChange={handleSelectAll}
+                      />
+                    </TableHead>
+                    {columns.map((col, idx) => (
+                      <TableHead key={idx} fit={col.fit} align={col.align}>
+                        {col.label}
+                      </TableHead>
+                    ))}
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {!isLoading && rows && rows.map((row) => (
+                    <Fragment key={row.id}>
+                      <TableRow>
+                        <TableCell className="py-3">
+                          <Checkbox
+                            checked={selectedItems.has(row.id)}
+                            onValueChange={() => handleToggleItem(row.id)}
+                          />
+                        </TableCell>
+                        {columns.map((col, idx) => (
+                          <TableCell key={idx} fit={col.fit} align={col.align} className="py-3">
+                            {col.tc(row)}
+                          </TableCell>
+                        ))}
+                      </TableRow>
+                    </Fragment>
+                  ))}
+                </TableBody>
+              </Table>
 
-      <div className="fixed-menu">
-        <Transition
-          visible={selectedKeys.length > 0}
-          animation="slide left"
-          duration={500}
-        >
-          <Message size="small" color="violet" className="text-center">
-            <span className="px-4">{selectedKeys.length}개 선택됨</span>
-            <Button size="tiny" color="violet" onClick={() => deselectAll()}>
-              선택 해제
-            </Button>
-            <Button size="tiny" color="red" onClick={confirmDelSelected}>
-              일괄 삭제
-            </Button>
-          </Message>
-        </Transition>
+              {/* Pagination */}
+              <Pagination
+                {...register("page")}
+                total={total ?? 0}
+                itemsPerPage={listParams.num ?? 10}
+              />
+            </CardContent>
+          </Card>
+        </div>
       </div>
+
+      {/* Delete Dialog */}
+      <AlertDialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Are you sure?</AlertDialogTitle>
+            <AlertDialogDescription>
+              This action cannot be undone. This will permanently delete this item.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction onClick={handleConfirmDelete}>Delete</AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
     </div>
   );
 }
@@ -475,4 +640,4 @@ export default function ${names.capital}List({}: ${names.capital}ListProps) {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_list.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport inflection from \"inflection\";\nimport { flat, unique } from \"radashi\";\nimport { z } from \"zod\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { getColumnsNode } from \"../entity-converter\";\nimport { getEnumInfoFromColName, getRelationPropFromColName } from \"../helpers\";\nimport type { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\n\nexport class Template__view_list extends Template {\n  constructor() {\n    super(\"view_list\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \"web/src/pages/admin\",\n      path: `${names.fsPlural}/index.tsx`,\n    };\n  }\n\n  wrapTc(body: string, key: string, collapsing: boolean = true, className: string = \"\") {\n    return `<Table.Cell key=\"${key}\"${collapsing ? \" collapsing\" : \"\"}${\n      className ? ` className={\\`${className}\\`}` : \"\"\n    }>${body}</Table.Cell>`;\n  }\n\n  renderColumn(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n    parentObj: string = \"row\",\n    withoutName: boolean = false,\n  ): string {\n    const colName = withoutName ? `${parentObj}` : `${parentObj}.${col.name}`;\n\n    switch (col.renderType) {\n      case \"string-plain\":\n      case \"string-date\":\n      case \"number-id\":\n        return `<>{${colName}}</>`;\n      case \"number-fk_id\": {\n        const relPropFk = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        return `<>${relPropFk.with}#{${colName}}</>`;\n      }\n      case \"string-image\":\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}<img src={${colName}} />}</>`;\n      case \"datetime\":\n        if (col.nullable) {\n          return `<span className=\"text-tiny\">{${colName} === null ? '-' : formatDateTime(${colName})}</span>`;\n        } else {\n          return `<span className=\"text-tiny\">{formatDateTime(${colName})}</span>`;\n        }\n      case \"string-datetime\":\n        if (col.nullable) {\n          return `<span className=\"text-tiny\">{${colName} === null ? '-' : dateF(${colName})}</span>`;\n        } else {\n          return `<span className=\"text-tiny\">{dateF(${colName})}</span>`;\n        }\n      case \"boolean\":\n        return `<>{${colName} ? <Label color='green' circular>O</Label> : <Label color='grey' circular>X</Label> }</>`;\n      case \"enums\": {\n        const { id: enumId } = getEnumInfoFromColName(entityId, col.name);\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}${enumId}Label[${colName}]}</>`;\n      }\n      case \"array-images\":\n        return `<>{ ${colName}.map(r => ${col.nullable ? `r && ` : \"\"}<img src={r} />) }</>`;\n      case \"number-plain\":\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}numF(${colName})}</>`;\n      case \"object\":\n        return `<>{/* object ${colName} */}</>`;\n      case \"object-pick\": {\n        const pickedChild = col.children?.find((child) => child.name === col.config?.picked);\n        if (!pickedChild) {\n          throw new Error(`object-pick 선택 실패 (오브젝트: ${col.name})`);\n        }\n        return this.renderColumn(\n          entityId,\n          pickedChild,\n          names,\n          `${colName}${col.nullable ? \"?\" : \"\"}`,\n        );\n      }\n      case \"array\":\n        return `<>{ /* array ${colName} */ }</>`;\n      case \"vector\":\n        // vector 타입은 차원 수만 표시 (실제 데이터는 너무 김)\n        return `<>{${col.nullable ? `${colName} ? ` : \"\"}[Vector: {${colName}${col.nullable ? \"\" : \" ?? []\"}.length}d]${col.nullable ? \" : '-'\" : \"\"}}</>`;\n      default:\n        throw new Error(`렌더 불가 컬럼 ${col.renderType}`);\n    }\n  }\n\n  renderColumnImport(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n  ): (string | null)[] {\n    if (col.renderType === \"enums\") {\n      const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);\n      return [`import { ${enumId}Label } from '@/services/sonamu.generated';`];\n    } else if (col.renderType === \"object\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name);\n        const result = col.children?.map((child) => {\n          entityId = relProp.with;\n          names = EntityManager.getNamesFromId(relProp.with);\n          return this.renderColumnImport(entityId, child, names);\n        });\n        return flat(result ?? []);\n      } catch {\n        return [null];\n      }\n    } else if (col.renderType === \"array\") {\n      assert(col.element);\n      return this.renderColumnImport(entityId, col.element, names);\n    }\n\n    return [null];\n  }\n\n  renderFilterImport(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return `import { ${names.capital}SearchInput } from \"@/components/${names.fs}/${names.capital}SearchInput\";`;\n    } else if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n        return `import { ${componentId} } from \"@/components/${names.fs}/${componentId}\";`;\n      } else {\n        try {\n          const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(\n            entityId,\n            col.name,\n          );\n          const componentId = `${id}Select`;\n          return `import { ${componentId} } from \"@/components/${targetMDNames.fs}/${componentId}\";`;\n        } catch {\n          return \"\";\n        }\n      }\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"@/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  renderFilter(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return \"\";\n    }\n\n    const isClearable = col.optional === true && col.name !== \"orderBy\";\n    let componentId: string;\n    if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n      } else {\n        try {\n          const { id } = getEnumInfoFromColName(entityId, col.name);\n          componentId = `${id}Select`;\n        } catch {\n          return \"\";\n        }\n      }\n      return `<${componentId} {...register('${col.name}')} ${isClearable ? \"clearable\" : \"\"} />`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        componentId = `${relProp.with}IdAsyncSelect`;\n        return `<${componentId} {...register('${col.name}')} ${\n          isClearable ? \"clearable\" : \"\"\n        } subset=\"A\" />`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  getDefault(columns: RenderingNode[]): {\n    orderBy: string;\n    search: string;\n  } {\n    const def = {\n      orderBy: \"id-desc\",\n      search: \"title\",\n    };\n    const orderByZodType = columns.find((col) => col.name === \"orderBy\")?.zodType;\n    if (orderByZodType && orderByZodType instanceof z.ZodEnum) {\n      def.orderBy = orderByZodType.options[0].toString();\n    }\n    const searchZodType = columns.find((col) => col.name === \"search\")?.zodType;\n    if (searchZodType && searchZodType instanceof z.ZodEnum) {\n      def.search = searchZodType.options[0].toString();\n    }\n    return def;\n  }\n\n  async render({ entityId }: TemplateOptions[\"view_list\"]) {\n    const columnsNode = await getColumnsNode(entityId, \"A\");\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    // 실제 리스트 컬럼\n    const columns = (columnsNode.children as RenderingNode[])\n      .filter((col) => col.name !== \"id\")\n      .map((col) => {\n        const propCandidate = entity.props.find((p) => p.name === col.name);\n        return {\n          name: col.name,\n          label: propCandidate?.desc ?? col.label,\n          tc: `(row) => ${this.renderColumn(entityId, col, names)}`,\n        };\n      });\n\n    // 필터 컬럼\n    const filterColumns = (listParamsNode.children as RenderingNode[])\n      .filter(\n        (col) =>\n          col.name !== \"id\" &&\n          col.name !== \"queryMode\" &&\n          ([\"enums\", \"number-id\"].includes(col.renderType) || col.name.endsWith(\"_id\")),\n      )\n      // orderBy가 가장 뒤로 오게 순서 조정\n      .sort((a) => {\n        return a.name === \"orderBy\" ? 1 : -1;\n      });\n\n    // 필터 컬럼을 프리 템플릿으로 설정\n    const preTemplates: RenderedTemplate[\"preTemplates\"] = [];\n    for (const col of filterColumns) {\n      let key: TemplateKey;\n      let targetEntityId = entityId;\n      let enumId: string | undefined;\n\n      if (col.renderType === \"enums\") {\n        if (col.name === \"search\") {\n          key = \"view_enums_dropdown\";\n          enumId = `${names.capital}SearchField`;\n          targetEntityId = names.capital;\n        } else {\n          key = \"view_enums_select\";\n          try {\n            const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);\n            targetEntityId = targetEntityNames.capital;\n            enumId = id;\n          } catch {\n            continue;\n          }\n        }\n      } else {\n        key = \"view_id_async_select\";\n        try {\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          targetEntityId = relProp.with;\n        } catch {\n          continue;\n        }\n      }\n\n      preTemplates.push({\n        key,\n        options: {\n          entityId: targetEntityId,\n          enumId,\n        },\n      });\n    }\n\n    // 리스트 컬럼\n    assert(columnsNode.children);\n    const columnImports = unique(\n      columnsNode.children\n        .flatMap((col) => {\n          return this.renderColumnImport(entityId, col, names);\n        })\n        .filter((col) => col !== null),\n    ).join(\"\\n\");\n\n    // SearchInput\n    assert(preTemplates);\n    preTemplates.push({\n      key: \"view_search_input\",\n      options: {\n        entityId,\n      },\n    });\n\n    // 디폴트 파라미터\n    const def = this.getDefault(filterColumns);\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport React from 'react';\nimport { Link } from 'react-router-dom';\nimport {\n  Breadcrumb,\n  Checkbox,\n  Pagination,\n  Segment,\n  Table,\n  TableRow,\n  Message,\n  Transition,\n  Button,\n  Label,\n} from 'semantic-ui-react';\nimport classNames from 'classnames';\nimport { DateTime } from \"luxon\";\nimport { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, formatDate, formatDateTime } from '@sonamu-kit/react-sui';\n\nimport { ${names.capital}SubsetA } from \"@/services/sonamu.generated\";\nimport { ${names.capital}Service } from '@/services/services.generated';\nimport { ${names.capital}ListParams } from '@/services/${names.fs}/${names.fs}.types';\n${columnImports}\n${filterColumns\n  .map((col) => {\n    return this.renderFilterImport(entityId, col, names);\n  })\n  .join(\"\\n\")}\n\ntype ${names.capital}ListProps = {};\nexport default function ${names.capital}List({}: ${names.capital}ListProps) {\n  // 리스트 필터\n  const { listParams, register } = useListParams(${names.capital}ListParams, {\n    num: 12,\n    page: 1,\n    orderBy: '${def.orderBy}',\n    search: '${def.search}',\n  });\n\n  // 리스트 쿼리\n  const { data, refetch, isLoading } = ${names.capital}Service.use${\n    names.capitalPlural\n  }('A', listParams);\n  const { rows, total } = data ?? {};\n\n  // 삭제\n  const confirmDel = (ids: number[]) => {\n    const answer = confirm('삭제하시겠습니까?');\n    if (!answer) {\n      return;\n    }\n\n    ${names.capital}Service.del(ids).then(() => {\n      refetch();\n    });\n  };\n\n  // 일괄 삭제\n  const confirmDelSelected = () => {\n    const answer = confirm(\\`\\${selectedKeys.length}건을 일괄 삭제하시겠습니까?\\`);\n    if (!answer) {\n      return;\n    }\n\n    ${names.capital}Service.del(selectedKeys).then(() => {\n      refetch();\n    });\n  };\n\n  // 현재 경로와 타이틀\n  const PAGE = {\n    route: '/admin/${names.fsPlural}',\n    title: '${entity.title ?? names.capital}',\n  };\n\n  // 선택\n  const {\n    getSelected,\n    isAllSelected,\n    selectedKeys,\n    toggle,\n    selectAll,\n    deselectAll,\n    handleCheckboxClick,\n  } = useSelection((rows ?? []).map((row) => row.id));\n\n  // 컬럼\n  const columns:SonamuCol<${names.capital}SubsetA>[] = [${columns\n    .map((col) => {\n      return [\n        `{ label: \"${col.label}\",`,\n        `tc: ${col.tc}, `,\n        `collapsing: ${[\"Title\", \"Name\"].includes(col.label) === false}, }`,\n      ].join(\"\\n\");\n    })\n    .join(\",\\n\")}];\n\n  return (\n    <div className=\"list ${names.fsPlural}-index\">\n      <div className=\"top-nav\">\n        <div className=\"header-row\">\n          <div className=\"header\">{PAGE.title}</div>\n          <AppBreadcrumbs>\n            <Breadcrumb.Section active>{PAGE.title}</Breadcrumb.Section>\n          </AppBreadcrumbs>\n          <${names.capital}SearchInput\n            input={register('keyword')}\n            dropdown={register('search')}\n          />\n        </div>\n        <div className=\"filters-row\">\n          ${filterColumns\n            .map((col) => {\n              return this.renderFilter(entityId, col, names);\n            })\n            .join(\"&nbsp;\\n\")}\n        </div>\n      </div>\n\n      <Segment basic padded className=\"contents-segment\" loading={isLoading}>\n        <div className=\"buttons-row\">\n          <div className={classNames('count', { hidden: isLoading })}>\n            {total} 건\n          </div>\n          <div className=\"buttons\">\n            <AddButton currentRoute={PAGE.route} icon=\"write\" label=\"추가\" />\n          </div>\n        </div>\n\n        <Table\n          celled\n          compact\n          selectable\n          className={classNames({ hidden: total === undefined || total === 0 })}\n        >\n          <Table.Header>\n            <TableRow>\n              <Table.HeaderCell collapsing>\n                <Checkbox\n                  label=\"ID\"\n                  checked={isAllSelected}\n                  onChange={isAllSelected ? deselectAll : selectAll}\n                />\n              </Table.HeaderCell>\n              {\n                /* Header */\n                columns.map((col, index) => col.th ?? <Table.HeaderCell key={index} collapsing={col.collapsing}>{ col.label }</Table.HeaderCell>)\n              }\n              <Table.HeaderCell>관리</Table.HeaderCell>\n            </TableRow>\n          </Table.Header>\n          <Table.Body>\n            {rows &&\n              rows.map((row, rowIndex) => (\n                <Table.Row key={row.id}>\n                  <Table.Cell>\n                    <Checkbox\n                      label={row.id}\n                      checked={getSelected(row.id)}\n                      onChange={() => toggle(row.id)}\n                      onClick={(e) =>\n                        handleCheckboxClick(e, rowIndex)\n                      }\n                    />\n                  </Table.Cell>\n                  {\n                    /* Body */\n                    columns.map((col, colIndex) => (\n                      <Table.Cell key={colIndex} collapsing={col.collapsing} className={col.className}>\n                        {col.tc(row, rowIndex)}\n                      </Table.Cell>\n                    ))\n                  }\n                  <Table.Cell collapsing>\n                    <EditButton\n                      as={Link}\n                      to={\\`\\${PAGE.route}/form?id=\\${row.id}\\`}\n                      state={{ from: PAGE.route }}\n                    />\n                    <DelButton onClick={() => confirmDel([row.id])} />\n                  </Table.Cell>\n                </Table.Row>\n              ))}\n          </Table.Body>\n        </Table>\n        <div\n          className={classNames('pagination-row', {\n            hidden: (total ?? 0) === 0,\n          })}\n        >\n          <Pagination\n            totalPages={Math.ceil((total ?? 0) / (listParams.num ?? 24))}\n            {...register('page')}\n          />\n        </div>\n      </Segment>\n\n      <div className=\"fixed-menu\">\n        <Transition\n          visible={selectedKeys.length > 0}\n          animation=\"slide left\"\n          duration={500}\n        >\n          <Message size=\"small\" color=\"violet\" className=\"text-center\">\n            <span className=\"px-4\">{selectedKeys.length}개 선택됨</span>\n            <Button size=\"tiny\" color=\"violet\" onClick={() => deselectAll()}>\n              선택 해제\n            </Button>\n            <Button size=\"tiny\" color=\"red\" onClick={confirmDelSelected}>\n              일괄 삭제\n            </Button>\n          </Message>\n        </Transition>\n      </div>\n    </div>\n  );\n}\n      `.trim(),\n      importKeys: [],\n      preTemplates,\n    };\n  }\n}\n"],"names":["assert","inflection","flat","unique","z","EntityManager","getColumnsNode","getEnumInfoFromColName","getRelationPropFromColName","Template","getZodTypeById","zodTypeToRenderingNode","Template__view_list","getTargetAndPath","names","target","path","fsPlural","wrapTc","body","key","collapsing","className","renderColumn","entityId","col","parentObj","withoutName","colName","name","renderType","relPropFk","replace","with","nullable","id","enumId","pickedChild","children","find","child","config","picked","Error","renderColumnImport","capital","relProp","result","map","getNamesFromId","element","renderFilterImport","fs","componentId","camelize","targetEntityNames","targetMDNames","targetNames","renderFilter","isClearable","optional","getDefault","columns","def","orderBy","search","orderByZodType","zodType","ZodEnum","options","toString","searchZodType","render","columnsNode","listParamsZodType","listParamsNode","entity","get","filter","propCandidate","props","p","label","desc","tc","filterColumns","includes","endsWith","sort","a","preTemplates","targetEntityId","push","columnImports","flatMap","join","capitalPlural","title","trim","importKeys"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_list.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { flat } from \"radashi\";\nimport { z } from \"zod\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { getEnumInfoFromColName, getRelationPropFromColName } from \"../helpers\";\nimport type { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\n\nexport class Template__view_list extends Template {\n  constructor() {\n    super(\"view_list\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \"web/src/routes/admin\",\n      path: `${names.fsPlural}/index.tsx`,\n    };\n  }\n\n  wrapTc(body: string, key: string, collapsing: boolean = true, className: string = \"\") {\n    return `<Table.Cell key=\"${key}\"${collapsing ? \" collapsing\" : \"\"}${\n      className ? ` className={\\`${className}\\`}` : \"\"\n    }>${body}</Table.Cell>`;\n  }\n\n  renderColumn(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n    parentObj: string = \"row\",\n    withoutName: boolean = false,\n  ): string {\n    // 중첩 경로 처리 (예: \"user.name\" -> \"row.user?.name\")\n    let colName: string;\n    if (withoutName) {\n      colName = parentObj;\n    } else if (col.name.includes(\".\")) {\n      // 중첩 경로는 optional chaining으로 변환\n      const parts = col.name.split(\".\");\n      colName = `${parentObj}.${parts.join(\"?.\")}`;\n    } else {\n      colName = `${parentObj}.${col.name}`;\n    }\n\n    switch (col.renderType) {\n      case \"string-plain\":\n      case \"string-date\":\n      case \"number-id\":\n        return `<>{${colName}}</>`;\n      case \"number-fk_id\": {\n        try {\n          const baseName = col.name.includes(\".\")\n            ? (col.name.split(\".\").pop() ?? col.name).replace(\"_id\", \"\")\n            : col.name.replace(\"_id\", \"\");\n          const relPropFk = getRelationPropFromColName(entityId, baseName);\n          return `<>${relPropFk.with}#{${colName}}</>`;\n        } catch {\n          return `<>{${colName}}</>`;\n        }\n      }\n      case \"string-image\":\n        return `<>{${\n          col.nullable ? `${colName} && ` : \"\"\n        }<img src={${colName}} alt=\"${col.label ?? col.name}\" className=\"h-8 w-8 object-cover rounded\" />}</>`;\n      case \"datetime\":\n        if (col.nullable || col.name.includes(\".\")) {\n          return `<span>{${colName} ? datetimeF(${colName}) : '-'}</span>`;\n        } else {\n          return `<span>{datetimeF(${colName})}</span>`;\n        }\n      case \"string-datetime\":\n        if (col.nullable || col.name.includes(\".\")) {\n          return `<span>{${colName} ? dateF(${colName}) : '-'}</span>`;\n        } else {\n          return `<span>{dateF(${colName})}</span>`;\n        }\n      case \"boolean\":\n        return `<>{${colName} ? <Badge variant=\"default\">O</Badge> : <Badge variant=\"secondary\">X</Badge>}</>`;\n      case \"enums\": {\n        try {\n          const { id: enumId } = getEnumInfoFromColName(entityId, col.name);\n          return `<>{${col.nullable ? `${colName} && ` : \"\"}${enumId}Label[${colName}]}</>`;\n        } catch {\n          return `<>{${colName}}</>`;\n        }\n      }\n      case \"array-images\":\n        return `<div className=\"flex gap-1\">{ ${colName}?.map((r, i) => ${\n          col.nullable ? `r && ` : \"\"\n        }<img key={i} src={r} alt={\\`${col.label ?? col.name} \\${i + 1}\\`} className=\"h-8 w-8 object-cover rounded\" />) }</div>`;\n      case \"number-plain\":\n        return `<>{${col.nullable || col.name.includes(\".\") ? `${colName} && ` : \"\"}numF(${colName})}</>`;\n      case \"object\":\n        return `<span className=\"text-xs\">{${col.nullable ? `${colName} ? ` : \"\"}JSON.stringify(${colName})${col.nullable ? ` : '-'` : \"\"}}</span>`;\n      case \"object-pick\": {\n        const pickedChild = col.children?.find((child) => child.name === col.config?.picked);\n        if (!pickedChild) {\n          throw new Error(`object-pick 선택 실패 (오브젝트: ${col.name})`);\n        }\n        return this.renderColumn(\n          entityId,\n          pickedChild,\n          names,\n          `${colName}${col.nullable ? \"?\" : \"\"}`,\n        );\n      }\n      case \"array\":\n        return `<>{ /* array ${colName} */ }</>`;\n      case \"vector\":\n        // vector 타입은 차원 수만 표시 (실제 데이터는 너무 김)\n        return `<>{${col.nullable ? `${colName} ? ` : \"\"}[Vector: {${colName}${col.nullable ? \"\" : \" ?? []\"}.length}d]${col.nullable ? \" : '-'\" : \"\"}}</>`;\n      default:\n        throw new Error(`렌더 불가 컬럼 ${col.renderType}`);\n    }\n  }\n\n  renderColumnImport(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n  ): (string | null)[] {\n    if (col.renderType === \"enums\") {\n      const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);\n      return [`import { ${enumId}Label } from '@/services/sonamu.generated';`];\n    } else if (col.renderType === \"object\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name);\n        const result = (col.children ?? []).map((child) => {\n          entityId = relProp.with;\n          names = EntityManager.getNamesFromId(relProp.with);\n          return this.renderColumnImport(entityId, child, names);\n        });\n        return flat(result);\n      } catch {\n        return [null];\n      }\n    } else if (col.renderType === \"array\") {\n      if (!col.element) return [null];\n      return this.renderColumnImport(entityId, col.element, names);\n    }\n\n    return [null];\n  }\n\n  renderFilterImport(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return `import { ${names.capital}SearchInput } from \"@/components/${names.fs}/${names.capital}SearchInput\";`;\n    } else if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n        return `import { ${componentId} } from \"@/components/${names.fs}/${componentId}\";`;\n      } else {\n        try {\n          const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(\n            entityId,\n            col.name,\n          );\n          const componentId = `${id}Select`;\n          return `import { ${componentId} } from \"@/components/${targetMDNames.fs}/${componentId}\";`;\n        } catch {\n          return \"\";\n        }\n      }\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"@/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  renderFilter(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return \"\";\n    }\n\n    const isClearable = col.optional === true && col.name !== \"orderBy\";\n    let componentId: string;\n    if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n      } else {\n        try {\n          const { id } = getEnumInfoFromColName(entityId, col.name);\n          componentId = `${id}Select`;\n        } catch {\n          return \"\";\n        }\n      }\n      return `<${componentId} {...register('${col.name}')} ${isClearable ? \"clearable\" : \"\"} />`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        componentId = `${relProp.with}IdAsyncSelect`;\n        return `<${componentId} {...register('${col.name}')} ${\n          isClearable ? \"clearable\" : \"\"\n        } subset=\"A\" />`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  getDefault(columns: RenderingNode[]): {\n    orderBy: string;\n    search: string;\n    hasSearch: boolean;\n    hasOrderBy: boolean;\n  } {\n    const def = {\n      orderBy: \"\",\n      search: \"\",\n      hasSearch: false,\n      hasOrderBy: false,\n    };\n    const orderByZodType = columns.find((col) => col.name === \"orderBy\")?.zodType;\n    if (orderByZodType && orderByZodType instanceof z.ZodEnum) {\n      def.orderBy = Object.keys(orderByZodType.enum)[0];\n      def.hasOrderBy = true;\n    }\n    const searchZodType = columns.find((col) => col.name === \"search\")?.zodType;\n    if (searchZodType && searchZodType instanceof z.ZodEnum) {\n      def.search = Object.keys(searchZodType.enum)[0];\n      def.hasSearch = true;\n    }\n    return def;\n  }\n\n  async render({ entityId }: TemplateOptions[\"view_list\"]) {\n    const { getColumnsNode } = await import(\"../entity-converter\");\n    const { getZodTypeById, zodTypeToRenderingNode } = await import(\"../zod-converter\");\n\n    const columnsNode = await getColumnsNode(entityId, \"A\");\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    // 실제 리스트 컬럼\n    const columns = (columnsNode.children as RenderingNode[])\n\n      .sort((a, b) => (a.name === \"id\" ? -1 : b.name === \"id\" ? 1 : 0))\n      .map((col) => {\n        const propCandidate = entity.props.find((p) => p.name === col.name);\n        const rendered = this.renderColumn(entityId, col, names);\n        return {\n          name: col.name,\n          label: col.name === \"id\" ? \"ID\" : (propCandidate?.desc ?? col.label),\n          tc: `(row) => ${rendered}`,\n          fit:\n            col.renderType === \"number-id\" ||\n            col.renderType === \"datetime\" ||\n            col.renderType === \"string-datetime\",\n          align: col.renderType === \"number-id\" ? \"center\" : undefined,\n        };\n      });\n\n    // 필터 컬럼\n    const filterColumns = (listParamsNode.children as RenderingNode[])\n      .filter(\n        (col) =>\n          col.name !== \"id\" &&\n          col.name !== \"queryMode\" &&\n          ([\"enums\", \"number-id\"].includes(col.renderType) || col.name.endsWith(\"_id\")),\n      )\n      // orderBy가 가장 뒤로 오게 순서 조정\n      .sort((a) => {\n        return a.name === \"orderBy\" ? 1 : -1;\n      });\n\n    // 필터 컬럼을 프리 템플릿으로 설정\n    const preTemplates: RenderedTemplate[\"preTemplates\"] = [];\n    for (const col of filterColumns) {\n      let key: TemplateKey;\n      let targetEntityId = entityId;\n      let enumId: string | undefined;\n\n      if (col.renderType === \"enums\") {\n        if (col.name === \"search\") {\n          key = \"view_enums_select\";\n          enumId = `${names.capital}SearchField`;\n          targetEntityId = names.capital;\n        } else {\n          key = \"view_enums_select\";\n          // config.enumId 우선 사용\n          if (col.config && \"enumId\" in col.config) {\n            enumId = (col.config as { enumId: string }).enumId;\n            targetEntityId = entityId;\n          } else {\n            try {\n              const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);\n              targetEntityId = targetEntityNames.capital;\n              enumId = id;\n            } catch {\n              continue;\n            }\n          }\n        }\n      } else {\n        key = \"view_id_async_select\";\n        try {\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          targetEntityId = relProp.with;\n        } catch {\n          continue;\n        }\n      }\n\n      preTemplates.push({\n        key,\n        options: {\n          entityId: targetEntityId,\n          enumId,\n        },\n      });\n    }\n\n    // 컬럼에서 사용하는 enum들 수집\n    const columnEnums: string[] = [];\n    (columnsNode.children ?? []).forEach((col) => {\n      if (col.renderType === \"enums\") {\n        try {\n          const { id: enumId } = getEnumInfoFromColName(entityId, col.name);\n          columnEnums.push(enumId);\n        } catch {}\n      }\n    });\n\n    // SearchInput\n    preTemplates?.push({\n      key: \"view_search_input\",\n      options: {\n        entityId,\n      },\n    });\n\n    // 디폴트 파라미터\n    // const def = this.getDefault(filterColumns);\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport { useState, Fragment } from \"react\";\nimport { createFileRoute, useNavigate } from \"@tanstack/react-router\";\n\nimport { Card, CardContent, CardHeader } from \"@sonamu-kit/react-components/components\";\nimport { Badge } from \"@sonamu-kit/react-components/components\";\nimport { Button } from \"@sonamu-kit/react-components/components\";\nimport { Pagination, Table, TableBody, TableCell, type TableCol, TableHead, TableHeader, TableRow } from \"@sonamu-kit/react-components/components\";\nimport { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from \"@sonamu-kit/react-components/components\";\nimport { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle } from \"@sonamu-kit/react-components/components\";\nimport { Input } from \"@sonamu-kit/react-components/components\";\nimport { Checkbox } from \"@sonamu-kit/react-components/components\";\n\nimport { useListParams, numF, dateF, datetimeF } from \"@sonamu-kit/react-components/lib\";\nimport { ${names.capital}SubsetA } from \"@/services/sonamu.generated\";\nimport { ${names.capital}Service } from \"@/services/services.generated\";\nimport { ${names.capital}ListParams } from \"@/services/${names.fs}/${names.fs}.types\";\nimport { ${(() => {\n        // 기본 enum 수집 (filterColumns에 있는 것만)\n        const baseEnums: string[] = [];\n        if (filterColumns.some((col) => col.name === \"orderBy\")) {\n          baseEnums.push(`${names.capital}OrderBy`, `${names.capital}OrderByLabel`);\n        }\n        if (filterColumns.some((col) => col.name === \"search\")) {\n          baseEnums.push(`${names.capital}SearchField`, `${names.capital}SearchFieldLabel`);\n        }\n\n        // 필터 enum 수집 (config.enumId 우선, 없으면 getEnumInfoFromColName)\n        const filterEnumIds = filterColumns\n          .filter(\n            (col) => col.renderType === \"enums\" && col.name !== \"search\" && col.name !== \"orderBy\",\n          )\n          .map((col) => {\n            if (col.config && \"enumId\" in col.config) {\n              return (col.config as { enumId: string }).enumId;\n            }\n            try {\n              const { id: enumId } = getEnumInfoFromColName(entityId, col.name);\n              return enumId;\n            } catch {\n              return null;\n            }\n          })\n          .filter(Boolean) as string[];\n\n        // 모든 enum 합치고 중복 제거\n        const allEnums = [...new Set([...filterEnumIds, ...columnEnums])];\n        const enumImports = allEnums.flatMap((enumId) => [`${enumId}`, `${enumId}Label`]);\n\n        return [...baseEnums, ...enumImports].join(\", \");\n      })()} } from \"@/services/sonamu.generated\";\n${(() => {\n  // FK 필드의 AsyncSelect 컴포넌트 import\n  const fkColumns = filterColumns.filter((col) => col.name.endsWith(\"_id\") && col.name !== \"id\");\n  return fkColumns\n    .map((col) => {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        return `import { ${relProp.with}IdAsyncSelect } from \"@/components/${targetNames.fs}/${relProp.with}IdAsyncSelect\";`;\n      } catch {\n        return \"\";\n      }\n    })\n    .filter(Boolean)\n    .join(\"\\n\");\n})()}\n${\n  filterColumns.some((col) => col.name === \"search\")\n    ? `\nimport { ${names.capital}SearchFieldSelect } from \"@/components/${names.fs}/${names.capital}SearchFieldSelect\";`\n    : \"\"\n}\n${\n  filterColumns.some((col) => col.name === \"orderBy\")\n    ? `\nimport { ${names.capital}OrderBySelect } from \"@/components/${names.fs}/${names.capital}OrderBySelect\";`\n    : \"\"\n}\n\nimport EditIcon from \"~icons/lucide/square-pen\";\nimport TrashIcon from \"~icons/lucide/trash-2\";\nimport ListIcon from \"~icons/mdi/format-list-bulleted\";\nimport SearchIcon from \"~icons/mdi/magnify\";\n\nexport const Route = createFileRoute(\"/admin/${names.fsPlural}/\")({\\n  head: () => ({\\n    meta: [\\n      { title: \"${entity.title ?? names.capital} List\" },\\n      { name: \"description\", content: \"${entity.title ?? names.capital} 목록 관리\" },\\n    ],\\n  }),\\n  component: ${names.capital}List,\\n});\\n\\ntype ${names.capital}ListProps = {};\n\nfunction ${names.capital}List({}: ${names.capital}ListProps) {\n  const navigate = useNavigate();\n\n  // 상태 관리\n  const [selectedItems, setSelectedItems] = useState<Set<number>>(new Set());\n  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);\n  const [itemToDelete, setItemToDelete] = useState<{ id: number; name?: string } | null>(null);\n\n  // 리스트 필터\n  const { listParams, register } = useListParams(${names.capital}ListParams, {\n    num: 10,\n    page: 1,\n    keyword: \"\",${\n      filterColumns.some((col) => col.name === \"search\")\n        ? `\n    search: ${names.capital}SearchField.options[0],`\n        : \"\"\n    }${\n      filterColumns.some((col) => col.name === \"orderBy\")\n        ? `\n    orderBy: ${names.capital}OrderBy.options[0],`\n        : \"\"\n    }\n  });\n\n  // 리스트 쿼리\n  const { data, refetch, isLoading } = ${names.capital}Service.use${names.capitalPlural}(\"A\", listParams);\n  const { rows, total } = data ?? {};\n\n  // 현재 경로와 타이틀\n  const PAGE = {\n    route: \"/admin/${names.fsPlural}\",\n    title: \"${entity.title ?? names.capital}\",\n  };\n\n  // 컬럼 정의\n  type ${names.capital}Row = NonNullable<typeof rows>[number];\n  const columns: TableCol<${names.capital}Row>[] = [\n${columns\n  .map(\n    (col) => `    {\n      label: \"${col.label}\",\n      tc: ${col.tc},${\n        col.fit\n          ? `\n      fit: true,`\n          : \"\"\n      }${\n        col.align\n          ? `\n      align: \"${col.align}\",`\n          : \"\"\n      }\n    }`,\n  )\n  .join(\",\\n\")},\n    {\n      label: \"Manage\",\n      fit: true,\n      align: \"center\",\n      tc: (row) => (\n        <div className=\"flex items-center justify-center gap-1\">\n          <Button\n            variant=\"yellow\"\n            size=\"xs\"\n            icon={<EditIcon />}\n            onClick={() => navigate({ to: \\`\\${PAGE.route}/form\\`, search: { id: row.id } })}\n          />\n          <Button\n            variant=\"red\"\n            size=\"xs\"\n            icon={<TrashIcon />}\n            onClick={() => handleDeleteClick(row.id)}\n          />\n        </div>\n      ),\n    },\n  ];\n\n  // 선택 핸들러\n  const handleToggleItem = (id: number) => {\n    const newSelection = new Set(selectedItems);\n    if (newSelection.has(id)) {\n      newSelection.delete(id);\n    } else {\n      newSelection.add(id);\n    }\n    setSelectedItems(newSelection);\n  };\n\n  const isAllSelected = () => {\n    return (rows?.length ?? 0) > 0 && rows!.every((row) => selectedItems.has(row.id));\n  };\n\n  const handleSelectAll = (checked: boolean) => {\n    if (checked) {\n      setSelectedItems(new Set(rows?.map((row) => row.id) ?? []));\n    } else {\n      setSelectedItems(new Set());\n    }\n  };\n\n  // 삭제 핸들러\n  const handleDeleteClick = (id: number, name?: string) => {\n    setItemToDelete({ id, name });\n    setDeleteDialogOpen(true);\n  };\n\n  const handleConfirmDelete = () => {\n    if (itemToDelete) {\n      ${names.capital}Service.del([itemToDelete.id]).then(() => {\n        refetch();\n      });\n    }\n    setDeleteDialogOpen(false);\n    setItemToDelete(null);\n  };\n\n  return (\n    <div className=\"flex-1 overflow-auto\">\n      <div className=\"max-w-[1800px] mx-auto p-8\">\n        <div className=\"space-y-6 mb-8\">\n          {/* Header */}\n          <div className=\"flex items-center gap-2\">\n            <ListIcon className=\"h-5 w-5\" />\n            <span className=\"text-lg font-semibold h-5\">{PAGE.title}</span>\n          </div>\n\n          <Card className=\"shadow-sm border-border/40 overflow-hidden\">\n            <CardHeader className=\"pb-0 px-0 pt-0\">\n              {/* Filters */}\n              <div className=\"bg-gray-100 px-6 py-4 space-y-3\">\n                <div className=\"flex items-center gap-3 flex-wrap\">\n${\n  filterColumns.some((col) => col.name === \"search\")\n    ? `                  <${names.capital}SearchFieldSelect\n                    {...register(\"search\")}\n                    placeholder=\"Search Type\"\n                    className=\"w-[200px] h-8 bg-white border-gray-300 text-xs\"\n                  />`\n    : \"\"\n}\n\n                  <div className=\"relative flex-1 max-w-xs\">\n                    <Input\n                      {...register(\"keyword\")}\n                      placeholder=\"Search...\"\n                      className=\"h-8 pr-8 text-xs bg-white border-gray-300\"\n                    />\n                    <Button\n                      variant=\"ghost\"\n                      size=\"sm\"\n                      icon={<SearchIcon />}\n                      className=\"absolute right-0 top-0 h-8 w-8 hover:bg-transparent\"\n                    />\n                  </div>\n\n                  <div className=\"ml-auto\">\n                    <Button\n                      className=\"h-8 px-4 bg-primary hover:bg-primary/90 text-white\"\n                      onClick={() => navigate({ to: \\`\\${PAGE.route}/form\\` })}\n                    >\n                      <span className=\"text-xs\">Create</span>\n                    </Button>\n                  </div>\n                </div>\n\n                <div className=\"flex items-center gap-3 flex-wrap\">\n${filterColumns\n  .filter((col) => col.name !== \"search\" && col.name !== \"orderBy\")\n  .map((col) => {\n    if (col.renderType === \"enums\") {\n      try {\n        // config.enumId가 있으면 우선 사용, 없으면 getEnumInfoFromColName 시도\n        const enumId =\n          col.config && \"enumId\" in col.config\n            ? (col.config as { enumId: string }).enumId\n            : getEnumInfoFromColName(entityId, col.name).id;\n        return `                  <Select key={\\`${col.name}-\\${listParams.${col.name}}\\`} {...register(\"${col.name}\")} clearable>\n                    <SelectTrigger className=\"w-[200px] h-8 bg-white border-gray-300 text-xs\">\n                      <SelectValue placeholder=\"${col.label}\" className=\"truncate\" />\n                    </SelectTrigger>\n                    <SelectContent>\n                      {${enumId}.options.map((key) => (\n                        <SelectItem key={key} value={key}>\n                          {${enumId}Label[key]}\n                        </SelectItem>\n                      ))}\n                    </SelectContent>\n                  </Select>`;\n      } catch {\n        return \"\";\n      }\n    }\n    // FK 필드 (AsyncSelect)\n    if (col.name.endsWith(\"_id\") && col.name !== \"id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        return `                  <${relProp.with}IdAsyncSelect\n                    subset=\"A\"\n                    {...register(\"${col.name}\")}\n                    placeholder=\"${col.label ?? relProp.with}\"\n                    clearable\n                    className=\"w-[200px] h-8 text-xs\"\n                  />`;\n      } catch {\n        return \"\";\n      }\n    }\n    return \"\";\n  })\n  .filter(Boolean)\n  .join(\"\\n\")}\n${\n  filterColumns.some((col) => col.name === \"orderBy\")\n    ? `                  <${names.capital}OrderBySelect\n                    {...register(\"orderBy\")}\n                    placeholder=\"Sort\"\n                    textPrefix=\"Sort: \"\n                    className=\"w-[200px] h-8 bg-white border-gray-300 text-xs\"\n                  />`\n    : \"\"\n}\n                  <span className=\"text-xs text-muted-foreground\">{total ?? 0} results</span>\n                </div>\n              </div>\n            </CardHeader>\n\n            <CardContent className=\"px-6 pb-6 pt-6 bg-white\">\n              {/* Table */}\n              <Table>\n                <TableHeader>\n                  <TableRow className=\"hover:bg-transparent bg-gray-100\">\n                    <TableHead className=\"h-9 text-xs w-[40px]\">\n                      <Checkbox\n                        checked={isAllSelected()}\n                        onValueChange={handleSelectAll}\n                      />\n                    </TableHead>\n                    {columns.map((col, idx) => (\n                      <TableHead key={idx} fit={col.fit} align={col.align}>\n                        {col.label}\n                      </TableHead>\n                    ))}\n                  </TableRow>\n                </TableHeader>\n                <TableBody>\n                  {!isLoading && rows && rows.map((row) => (\n                    <Fragment key={row.id}>\n                      <TableRow>\n                        <TableCell className=\"py-3\">\n                          <Checkbox\n                            checked={selectedItems.has(row.id)}\n                            onValueChange={() => handleToggleItem(row.id)}\n                          />\n                        </TableCell>\n                        {columns.map((col, idx) => (\n                          <TableCell key={idx} fit={col.fit} align={col.align} className=\"py-3\">\n                            {col.tc(row)}\n                          </TableCell>\n                        ))}\n                      </TableRow>\n                    </Fragment>\n                  ))}\n                </TableBody>\n              </Table>\n\n              {/* Pagination */}\n              <Pagination\n                {...register(\"page\")}\n                total={total ?? 0}\n                itemsPerPage={listParams.num ?? 10}\n              />\n            </CardContent>\n          </Card>\n        </div>\n      </div>\n\n      {/* Delete Dialog */}\n      <AlertDialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>\n        <AlertDialogContent>\n          <AlertDialogHeader>\n            <AlertDialogTitle>Are you sure?</AlertDialogTitle>\n            <AlertDialogDescription>\n              This action cannot be undone. This will permanently delete this item.\n            </AlertDialogDescription>\n          </AlertDialogHeader>\n          <AlertDialogFooter>\n            <AlertDialogCancel>Cancel</AlertDialogCancel>\n            <AlertDialogAction onClick={handleConfirmDelete}>Delete</AlertDialogAction>\n          </AlertDialogFooter>\n        </AlertDialogContent>\n      </AlertDialog>\n    </div>\n  );\n}\n      `.trim(),\n      importKeys: [],\n      preTemplates,\n    };\n  }\n}\n"],"names":["inflection","flat","z","EntityManager","getEnumInfoFromColName","getRelationPropFromColName","Template","Template__view_list","getTargetAndPath","names","target","path","fsPlural","wrapTc","body","key","collapsing","className","renderColumn","entityId","col","parentObj","withoutName","colName","name","includes","parts","split","join","renderType","baseName","pop","replace","relPropFk","with","nullable","label","id","enumId","pickedChild","children","find","child","config","picked","Error","renderColumnImport","capital","relProp","result","map","getNamesFromId","element","renderFilterImport","fs","componentId","camelize","targetEntityNames","targetMDNames","targetNames","renderFilter","isClearable","optional","getDefault","columns","def","orderBy","search","hasSearch","hasOrderBy","orderByZodType","zodType","ZodEnum","Object","keys","enum","searchZodType","render","getColumnsNode","getZodTypeById","zodTypeToRenderingNode","columnsNode","listParamsZodType","listParamsNode","entity","get","sort","a","b","propCandidate","props","p","rendered","desc","tc","fit","align","undefined","filterColumns","filter","endsWith","preTemplates","targetEntityId","push","options","columnEnums","forEach","baseEnums","some","filterEnumIds","Boolean","allEnums","Set","enumImports","flatMap","fkColumns","title","capitalPlural","trim","importKeys"],"mappings":"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"}