sonamu 0.5.6 → 0.6.0

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

@@ -0,0 +1,465 @@
+import inflection from "inflection";
+import * as _ from "lodash-es";
+import { z } from "zod";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { getRelationPropFromColName, getEnumInfoFromColName } from "../helpers.js";
+import { Template } from "../template.js";
+import { zodTypeToRenderingNode, getZodTypeById } from "../zod-converter.js";
+import { getColumnsNode } from "../entity-converter.js";
+export class Template__view_list extends Template {
+    constructor(){
+        super("view_list");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: "web/src/pages/admin",
+            path: `${names.fsPlural}/index.tsx`
+        };
+    }
+    wrapTc(body, key, collapsing = true, className = "") {
+        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}`;
+        switch(col.renderType){
+            case "string-plain":
+            case "string-date":
+            case "number-id":
+                return `<>{${colName}}</>`;
+            case "number-fk_id":
+                const relPropFk = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                return `<>${relPropFk.with}#{${colName}}</>`;
+            case "string-image":
+                return `<>{${col.nullable ? `${colName} && ` : ""}<img src={${colName}} />}</>`;
+            case "datetime":
+                if (col.nullable) {
+                    return `<span className="text-tiny">{${colName} === null ? '-' : formatDateTime(${colName})}</span>`;
+                } else {
+                    return `<span className="text-tiny">{formatDateTime(${colName})}</span>`;
+                }
+            case "string-datetime":
+                if (col.nullable) {
+                    return `<span className="text-tiny">{${colName} === null ? '-' : dateF(${colName})}</span>`;
+                } else {
+                    return `<span className="text-tiny">{dateF(${colName})}</span>`;
+                }
+            case "boolean":
+                return `<>{${colName} ? <Label color='green' circular>O</Label> : <Label color='grey' circular>X</Label> }</>`;
+            case "enums":
+                const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
+                return `<>{${col.nullable ? `${colName} && ` : ""}${enumId}Label[${colName}]}</>`;
+            case "array-images":
+                return `<>{ ${colName}.map(r => ${col.nullable ? `r && ` : ""}<img src={r} />) }</>`;
+            case "number-plain":
+                return `<>{${col.nullable ? `${colName} && ` : ""}numF(${colName})}</>`;
+            case "object":
+                return `<>{/* object ${colName} */}</>`;
+            case "object-pick":
+                const pickedChild = col.children.find((child)=>child.name === col.config?.picked);
+                if (!pickedChild) {
+                    throw new Error(`object-pick 선택 실패 (오브젝트: ${col.name})`);
+                }
+                return this.renderColumn(entityId, pickedChild, names, `${colName}${col.nullable ? "?" : ""}`);
+            case "array":
+                return `<>{ /* array ${colName} */ }</>`;
+            default:
+                throw new Error(`렌더 불가 컬럼 ${col.renderType}`);
+        }
+    }
+    renderColumnImport(entityId, col, names) {
+        if (col.renderType === "enums") {
+            const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);
+            return [
+                `import { ${enumId}Label } from 'src/services/sonamu.generated';`
+            ];
+        } else if (col.renderType === "object") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name);
+                const result = col.children.map((child)=>{
+                    entityId = relProp.with;
+                    names = EntityManager.getNamesFromId(relProp.with);
+                    return this.renderColumnImport(entityId, child, names);
+                });
+                return _.flattenDeep(result);
+            } catch  {
+                return [
+                    null
+                ];
+            }
+        } else if (col.renderType === "array") {
+            return this.renderColumnImport(entityId, col.element, names);
+        }
+        return [
+            null
+        ];
+    }
+    renderFilterImport(entityId, col, names) {
+        if (col.name === "search") {
+            return `import { ${names.capital}SearchInput } from "src/components/${names.fs}/${names.capital}SearchInput";`;
+        } else if (col.renderType === "enums") {
+            if (col.name === "orderBy") {
+                const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;
+                return `import { ${componentId} } from "src/components/${names.fs}/${componentId}";`;
+            } else {
+                try {
+                    const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(entityId, col.name);
+                    const componentId = `${id}Select`;
+                    return `import { ${componentId} } from "src/components/${targetMDNames.fs}/${componentId}";`;
+                } catch  {
+                    return "";
+                }
+            }
+        } else if (col.renderType === "number-fk_id") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                const targetNames = EntityManager.getNamesFromId(relProp.with);
+                const componentId = `${relProp.with}IdAsyncSelect`;
+                return `import { ${componentId} } from "src/components/${targetNames.fs}/${componentId}";`;
+            } catch  {
+                return "";
+            }
+        } else {
+            throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);
+        }
+    }
+    renderFilter(entityId, col, names) {
+        if (col.name === "search") {
+            return "";
+        }
+        const isClearable = col.optional === true && col.name !== "orderBy";
+        let componentId;
+        if (col.renderType === "enums") {
+            if (col.name === "orderBy") {
+                componentId = `${names.capital}${inflection.camelize(col.name)}Select`;
+            } else {
+                try {
+                    const { id } = getEnumInfoFromColName(entityId, col.name);
+                    componentId = `${id}Select`;
+                } catch  {
+                    return "";
+                }
+            }
+            return `<${componentId} {...register('${col.name}')} ${isClearable ? "clearable" : ""} />`;
+        } else if (col.renderType === "number-fk_id") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                componentId = `${relProp.with}IdAsyncSelect`;
+                return `<${componentId} {...register('${col.name}')} ${isClearable ? "clearable" : ""} subset="A" />`;
+            } catch  {
+                return "";
+            }
+        } else {
+            throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);
+        }
+    }
+    getDefault(columns) {
+        const def = {
+            orderBy: "id-desc",
+            search: "title"
+        };
+        const orderByZodType = columns.find((col)=>col.name === "orderBy")?.zodType;
+        if (orderByZodType && orderByZodType instanceof z.ZodEnum) {
+            def.orderBy = orderByZodType.options[0].toString();
+        }
+        const searchZodType = columns.find((col)=>col.name === "search")?.zodType;
+        if (searchZodType && searchZodType instanceof z.ZodEnum) {
+            def.search = searchZodType.options[0].toString();
+        }
+        return def;
+    }
+    async render({ entityId }) {
+        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 propCandidate = entity.props.find((p)=>p.name === col.name);
+            return {
+                name: col.name,
+                label: propCandidate?.desc ?? col.label,
+                tc: `(row) => ${this.renderColumn(entityId, col, names)}`
+            };
+        });
+        // 필터 컬럼
+        const filterColumns = listParamsNode.children.filter((col)=>col.name !== "id" && col.name !== "queryMode" && ([
+                "enums",
+                "number-id"
+            ].includes(col.renderType) || col.name.endsWith("_id")))// orderBy가 가장 뒤로 오게 순서 조정
+        .sort((a)=>{
+            return a.name == "orderBy" ? 1 : -1;
+        });
+        // 필터 컬럼을 프리 템플릿으로 설정
+        const preTemplates = [];
+        for (let col of filterColumns){
+            let key;
+            let targetEntityId = entityId;
+            let enumId;
+            if (col.renderType === "enums") {
+                if (col.name === "search") {
+                    key = "view_enums_dropdown";
+                    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;
+                    }
+                }
+            } else {
+                key = "view_id_async_select";
+                try {
+                    const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                    targetEntityId = relProp.with;
+                } catch  {
+                    continue;
+                }
+            }
+            preTemplates.push({
+                key,
+                options: {
+                    entityId: targetEntityId,
+                    enumId
+                }
+            });
+        }
+        // 리스트 컬럼
+        const columnImports = _.uniq(columnsNode.children.map((col)=>{
+            return this.renderColumnImport(entityId, col, names);
+        }).flat().filter((col)=>col !== null)).join("\n");
+        // SearchInput
+        preTemplates.push({
+            key: "view_search_input",
+            options: {
+                entityId
+            }
+        });
+        // 디폴트 파라미터
+        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 { ${names.capital}SubsetA } from "src/services/sonamu.generated";
+import { ${names.capital}Service } from 'src/services/${names.fs}/${names.fs}.service';
+import { ${names.capital}ListParams } from 'src/services/${names.fs}/${names.fs}.types';
+${columnImports}
+${filterColumns.map((col)=>{
+                return this.renderFilterImport(entityId, col, names);
+            }).join("\n")}
+
+type ${names.capital}ListProps = {};
+export default function ${names.capital}List({}: ${names.capital}ListProps) {
+  // 리스트 필터
+  const { listParams, register } = useListParams(${names.capital}ListParams, {
+    num: 12,
+    page: 1,
+    orderBy: '${def.orderBy}',
+    search: '${def.search}',
+  });
+
+  // 리스트 쿼리
+  const { data, mutate, error, 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(() => {
+      mutate();
+    });
+  };
+
+  // 일괄 삭제
+  const confirmDelSelected = () => {
+    const answer = confirm(\`\${selectedKeys.length}건을 일괄 삭제하시겠습니까?\`);
+    if (!answer) {
+      return;
+    }
+
+    ${names.capital}Service.del(selectedKeys).then(() => {
+      mutate();
+    });
+  };
+
+  // 현재 경로와 타이틀
+  const PAGE = {
+    route: '/admin/${names.fsPlural}',
+    title: '${entity.title ?? names.capital}',
+  };
+
+  // 선택
+  const {
+    getSelected,
+    isAllSelected,
+    selectedKeys,
+    toggle,
+    selectAll,
+    deselectAll,
+    handleCheckboxClick,
+  } = useSelection((rows ?? []).map((row) => row.id));
+
+  // 컬럼
+  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")}];
+
+  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>
+        </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)
+                      }
+                    />
+                  </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 }}
+                    />
+                    <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 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>
+      </div>
+    </div>
+  );
+}
+      `.trim(),
+            importKeys: [],
+            preTemplates
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_list.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport * as _ from \"lodash-es\";\nimport { z } from \"zod\";\nimport { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { EntityManager, EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { getRelationPropFromColName, getEnumInfoFromColName } from \"../helpers\";\nimport { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\nimport { zodTypeToRenderingNode, getZodTypeById } from \"../zod-converter\";\nimport { getColumnsNode } from \"../entity-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(\n    body: string,\n    key: string,\n    collapsing: boolean = true,\n    className: string = \"\"\n  ) {\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(\n          entityId,\n          col.name.replace(\"_id\", \"\")\n        );\n        return `<>${relPropFk.with}#{${colName}}</>`;\n      case \"string-image\":\n        return `<>{${\n          col.nullable ? `${colName} && ` : \"\"\n        }<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 `<>{${\n          col.nullable ? `${colName} && ` : \"\"\n        }${enumId}Label[${colName}]}</>`;\n      case \"array-images\":\n        return `<>{ ${colName}.map(r => ${\n          col.nullable ? `r && ` : \"\"\n        }<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(\n          (child) => child.name === col.config?.picked\n        );\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      case \"array\":\n        return `<>{ /* array ${colName} */ }</>`;\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 [\n        `import { ${enumId}Label } from 'src/services/sonamu.generated';`,\n      ];\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 _.flattenDeep(result);\n      } catch {\n        return [null];\n      }\n    } else if (col.renderType === \"array\") {\n      return this.renderColumnImport(entityId, col.element!, names);\n    }\n\n    return [null];\n  }\n\n  renderFilterImport(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord\n  ) {\n    if (col.name === \"search\") {\n      return `import { ${names.capital}SearchInput } from \"src/components/${names.fs}/${names.capital}SearchInput\";`;\n    } else if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        const componentId = `${names.capital}${inflection.camelize(\n          col.name\n        )}Select`;\n        return `import { ${componentId} } from \"src/components/${names.fs}/${componentId}\";`;\n      } else {\n        try {\n          const { id, targetEntityNames: targetMDNames } =\n            getEnumInfoFromColName(entityId, col.name);\n          const componentId = `${id}Select`;\n          return `import { ${componentId} } from \"src/components/${targetMDNames.fs}/${componentId}\";`;\n        } catch {\n          return \"\";\n        }\n      }\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(\n          entityId,\n          col.name.replace(\"_id\", \"\")\n        );\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"src/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(\n        `렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`\n      );\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}')} ${\n        isClearable ? \"clearable\" : \"\"\n      } />`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(\n          entityId,\n          col.name.replace(\"_id\", \"\")\n        );\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(\n        `렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`\n      );\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(\n      (col) => col.name === \"orderBy\"\n    )?.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) ||\n            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 (let 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(\n              entityId,\n              col.name\n            );\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(\n            entityId,\n            col.name.replace(\"_id\", \"\")\n          );\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    const columnImports = _.uniq(\n      columnsNode\n        .children!.map((col) => {\n          return this.renderColumnImport(entityId, col, names);\n        })\n        .flat()\n        .filter((col) => col !== null)\n    ).join(\"\\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 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 \"src/services/sonamu.generated\";\nimport { ${names.capital}Service } from 'src/services/${names.fs}/${\n        names.fs\n      }.service';\nimport { ${names.capital}ListParams } from 'src/services/${names.fs}/${\n        names.fs\n      }.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, mutate, error, 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      mutate();\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      mutate();\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":["inflection","_","z","EntityManager","getRelationPropFromColName","getEnumInfoFromColName","Template","zodTypeToRenderingNode","getZodTypeById","getColumnsNode","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","flattenDeep","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","uniq","flat","join","capitalPlural","title","trim","importKeys"],"mappings":"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"}

package/dist/{templates → template/implementations}/view_list_columns.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
 export declare class Template__view_list_columns extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {

package/dist/template/implementations/view_list_columns.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_list_columns.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_list_columns.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAQzC,MAAM,CAAC,EACL,QAAQ,EACR,OAAO,EACP,aAAa,GACd,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAqCxC"}

package/dist/template/implementations/view_list_columns.template.js

@@ -0,0 +1,49 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+export class Template__view_list_columns extends Template {
+    constructor(){
+        super("view_list_columns");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: "web/src/pages/admin",
+            path: `${names.fsPlural}/_columns.tsx`
+        };
+    }
+    // 컬럼
+    render({ entityId, columns, columnImports }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import React from 'react';
+import {
+  Segment,
+  Table,
+  TableRow,
+  Button,
+  Label,
+} from 'semantic-ui-react';
+import { DateTime } from "luxon";
+import { TFColumn } from "src/typeframe/iso-types";
+import { ${names.capital}SubsetA } from "src/services/${names.fs}/${names.fs}.generated";
+${columnImports}
+
+const columns: { [key in Exclude<keyof ${names.capital}SubsetA, 'id'>]: TFColumn<${names.capital}SubsetA> } = {${columns.map((col)=>{
+                return [
+                    `${col.name}: { label: "${col.label}",`,
+                    `tc: ${col.tc}, `,
+                    `collapsing: ${[
+                        "Title",
+                        "Name"
+                    ].includes(col.label) === false}, }`
+                ].join("\n");
+            }).join(",\n")}};
+export default columns;
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZW1wbGF0ZS9pbXBsZW1lbnRhdGlvbnMvdmlld19saXN0X2NvbHVtbnMudGVtcGxhdGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGVtcGxhdGVPcHRpb25zIH0gZnJvbSBcIi4uLy4uL3R5cGVzL3R5cGVzXCI7XG5pbXBvcnQgeyBFbnRpdHlNYW5hZ2VyLCBFbnRpdHlOYW1lc1JlY29yZCB9IGZyb20gXCIuLi8uLi9lbnRpdHkvZW50aXR5LW1hbmFnZXJcIjtcbmltcG9ydCB7IFRlbXBsYXRlIH0gZnJvbSBcIi4uL3RlbXBsYXRlXCI7XG5cbmV4cG9ydCBjbGFzcyBUZW1wbGF0ZV9fdmlld19saXN0X2NvbHVtbnMgZXh0ZW5kcyBUZW1wbGF0ZSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKFwidmlld19saXN0X2NvbHVtbnNcIik7XG4gIH1cblxuICBnZXRUYXJnZXRBbmRQYXRoKG5hbWVzOiBFbnRpdHlOYW1lc1JlY29yZCkge1xuICAgIHJldHVybiB7XG4gICAgICB0YXJnZXQ6IFwid2ViL3NyYy9wYWdlcy9hZG1pblwiLFxuICAgICAgcGF0aDogYCR7bmFtZXMuZnNQbHVyYWx9L19jb2x1bW5zLnRzeGAsXG4gICAgfTtcbiAgfVxuXG4gIC8vIOy7rOufvFxuICByZW5kZXIoe1xuICAgIGVudGl0eUlkLFxuICAgIGNvbHVtbnMsXG4gICAgY29sdW1uSW1wb3J0cyxcbiAgfTogVGVtcGxhdGVPcHRpb25zW1widmlld19saXN0X2NvbHVtbnNcIl0pIHtcbiAgICBjb25zdCBuYW1lcyA9IEVudGl0eU1hbmFnZXIuZ2V0TmFtZXNGcm9tSWQoZW50aXR5SWQpO1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIC4uLnRoaXMuZ2V0VGFyZ2V0QW5kUGF0aChuYW1lcyksXG4gICAgICBib2R5OiBgXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtcbiAgU2VnbWVudCxcbiAgVGFibGUsXG4gIFRhYmxlUm93LFxuICBCdXR0b24sXG4gIExhYmVsLFxufSBmcm9tICdzZW1hbnRpYy11aS1yZWFjdCc7XG5pbXBvcnQgeyBEYXRlVGltZSB9IGZyb20gXCJsdXhvblwiO1xuaW1wb3J0IHsgVEZDb2x1bW4gfSBmcm9tIFwic3JjL3R5cGVmcmFtZS9pc28tdHlwZXNcIjtcbmltcG9ydCB7ICR7bmFtZXMuY2FwaXRhbH1TdWJzZXRBIH0gZnJvbSBcInNyYy9zZXJ2aWNlcy8ke25hbWVzLmZzfS8ke1xuICAgICAgICBuYW1lcy5mc1xuICAgICAgfS5nZW5lcmF0ZWRcIjtcbiR7Y29sdW1uSW1wb3J0c31cblxuY29uc3QgY29sdW1uczogeyBba2V5IGluIEV4Y2x1ZGU8a2V5b2YgJHtcbiAgICAgICAgbmFtZXMuY2FwaXRhbFxuICAgICAgfVN1YnNldEEsICdpZCc+XTogVEZDb2x1bW48JHtuYW1lcy5jYXBpdGFsfVN1YnNldEE+IH0gPSB7JHtjb2x1bW5zXG4gICAgICAgIC5tYXAoKGNvbCkgPT4ge1xuICAgICAgICAgIHJldHVybiBbXG4gICAgICAgICAgICBgJHtjb2wubmFtZX06IHsgbGFiZWw6IFwiJHtjb2wubGFiZWx9XCIsYCxcbiAgICAgICAgICAgIGB0YzogJHtjb2wudGN9LCBgLFxuICAgICAgICAgICAgYGNvbGxhcHNpbmc6ICR7W1wiVGl0bGVcIiwgXCJOYW1lXCJdLmluY2x1ZGVzKGNvbC5sYWJlbCkgPT09IGZhbHNlfSwgfWAsXG4gICAgICAgICAgXS5qb2luKFwiXFxuXCIpO1xuICAgICAgICB9KVxuICAgICAgICAuam9pbihcIixcXG5cIil9fTtcbmV4cG9ydCBkZWZhdWx0IGNvbHVtbnM7XG4gICAgICBgLnRyaW0oKSxcbiAgICAgIGltcG9ydEtleXM6IFtdLFxuICAgIH07XG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJFbnRpdHlNYW5hZ2VyIiwiVGVtcGxhdGUiLCJUZW1wbGF0ZV9fdmlld19saXN0X2NvbHVtbnMiLCJnZXRUYXJnZXRBbmRQYXRoIiwibmFtZXMiLCJ0YXJnZXQiLCJwYXRoIiwiZnNQbHVyYWwiLCJyZW5kZXIiLCJlbnRpdHlJZCIsImNvbHVtbnMiLCJjb2x1bW5JbXBvcnRzIiwiZ2V0TmFtZXNGcm9tSWQiLCJib2R5IiwiY2FwaXRhbCIsImZzIiwibWFwIiwiY29sIiwibmFtZSIsImxhYmVsIiwidGMiLCJpbmNsdWRlcyIsImpvaW4iLCJ0cmltIiwiaW1wb3J0S2V5cyJdLCJtYXBwaW5ncyI6IkFBQ0EsU0FBU0EsYUFBYSxRQUEyQixpQ0FBOEI7QUFDL0UsU0FBU0MsUUFBUSxRQUFRLGlCQUFjO0FBRXZDLE9BQU8sTUFBTUMsb0NBQW9DRDtJQUMvQyxhQUFjO1FBQ1osS0FBSyxDQUFDO0lBQ1I7SUFFQUUsaUJBQWlCQyxLQUF3QixFQUFFO1FBQ3pDLE9BQU87WUFDTEMsUUFBUTtZQUNSQyxNQUFNLEdBQUdGLE1BQU1HLFFBQVEsQ0FBQyxhQUFhLENBQUM7UUFDeEM7SUFDRjtJQUVBLEtBQUs7SUFDTEMsT0FBTyxFQUNMQyxRQUFRLEVBQ1JDLE9BQU8sRUFDUEMsYUFBYSxFQUN3QixFQUFFO1FBQ3ZDLE1BQU1QLFFBQVFKLGNBQWNZLGNBQWMsQ0FBQ0g7UUFFM0MsT0FBTztZQUNMLEdBQUcsSUFBSSxDQUFDTixnQkFBZ0IsQ0FBQ0MsTUFBTTtZQUMvQlMsTUFBTSxDQUFDOzs7Ozs7Ozs7OztTQVdKLEVBQUVULE1BQU1VLE9BQU8sQ0FBQyw2QkFBNkIsRUFBRVYsTUFBTVcsRUFBRSxDQUFDLENBQUMsRUFDMURYLE1BQU1XLEVBQUUsQ0FDVDtBQUNQLEVBQUVKLGNBQWM7O3VDQUV1QixFQUMvQlAsTUFBTVUsT0FBTyxDQUNkLDBCQUEwQixFQUFFVixNQUFNVSxPQUFPLENBQUMsY0FBYyxFQUFFSixRQUN4RE0sR0FBRyxDQUFDLENBQUNDO2dCQUNKLE9BQU87b0JBQ0wsR0FBR0EsSUFBSUMsSUFBSSxDQUFDLFlBQVksRUFBRUQsSUFBSUUsS0FBSyxDQUFDLEVBQUUsQ0FBQztvQkFDdkMsQ0FBQyxJQUFJLEVBQUVGLElBQUlHLEVBQUUsQ0FBQyxFQUFFLENBQUM7b0JBQ2pCLENBQUMsWUFBWSxFQUFFO3dCQUFDO3dCQUFTO3FCQUFPLENBQUNDLFFBQVEsQ0FBQ0osSUFBSUUsS0FBSyxNQUFNLE1BQU0sR0FBRyxDQUFDO2lCQUNwRSxDQUFDRyxJQUFJLENBQUM7WUFDVCxHQUNDQSxJQUFJLENBQUMsT0FBTzs7TUFFZixDQUFDLENBQUNDLElBQUk7WUFDTkMsWUFBWSxFQUFFO1FBQ2hCO0lBQ0Y7QUFDRiJ9

package/dist/{templates → template/implementations}/view_search_input.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
 export declare class Template__view_search_input extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {

package/dist/template/implementations/view_search_input.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_search_input.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_search_input.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAkD1D"}