sonamu 0.8.26 → 0.9.0

package/dist/dict/sonamu-dictionary.js

@@ -1,960 +1,892 @@
-import { Workbook } from "@sheetkit/node";
-import { execSync } from "child_process";
-import fs from "fs";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { SD, init_sd } from "./sd.js";
+import { BadRequestException, init_so_exceptions } from "../exceptions/so-exceptions.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { formatCode, init_formatter } from "../utils/formatter.js";
 import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+import { Workbook } from "@sheetkit/node";
 import ts from "typescript";
-import { Sonamu } from "../api/sonamu.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { BadRequestException } from "../exceptions/so-exceptions.js";
-import { formatCode } from "../utils/formatter.js";
-import { SD } from "./sd.js";
-/**
- * 0-based 컬럼 인덱스를 엑셀 컬럼 문자로 변환 (0 -> "A", 25 -> "Z", 26 -> "AA")
- */ function colLetter(index) {
-    let result = "";
-    let n = index;
-    while(n >= 0){
-        result = String.fromCharCode(65 + n % 26) + result;
-        n = Math.floor(n / 26) - 1;
-    }
-    return result;
-}
+
+//#region src/dict/sonamu-dictionary.ts
 /**
- * Sonamu Dictionary 관리 클래스
- * i18n 딕셔너리의 CRUD 및 Excel import/export를 담당합니다.
- */ export class SonamuDictionary {
-    /**
-   * TypeScript Compiler API를 사용하여 dict 파일 파싱
-   *
-   * 지원 패턴:
-   * - export default { ... } as const;
-   * - export default defineLocale({ ... });
-   * - 문자열 값: "key": "value" 또는 key: `value`
-   * - 함수 값: "key": (param: Type) => `template`
-   */ parseDictFile(filePath) {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        const entries = [];
-        ts.forEachChild(sourceFile, (node)=>{
-            if (ts.isExportAssignment(node)) {
-                const objectLiteral = this.unwrapToObjectLiteral(node.expression);
-                if (objectLiteral) {
-                    this.extractEntriesFromObject(objectLiteral, sourceFile, entries);
-                }
-            }
-        });
-        return entries;
-    }
-    /**
-   * 파일에서 특정 이름의 const 선언을 찾아 ObjectLiteral 파싱
-   * 예: const entityLabels = { ... } as const;
-   */ parseConstObjectDeclaration(filePath, varName) {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        const entries = [];
-        ts.forEachChild(sourceFile, (node)=>{
-            if (ts.isVariableStatement(node)) {
-                for (const decl of node.declarationList.declarations){
-                    if (ts.isIdentifier(decl.name) && decl.name.text === varName && decl.initializer) {
-                        const objectLiteral = this.unwrapToObjectLiteral(decl.initializer);
-                        if (objectLiteral) {
-                            this.extractEntriesFromObject(objectLiteral, sourceFile, entries);
-                        }
-                    }
-                }
-            }
-        });
-        return entries;
-    }
-    /**
-   * 문자열이 화살표 함수 또는 함수 표현식인지 판별
-   */ isExpressionFunction(code) {
-        // 빈 문자열이나 공백만 있는 경우
-        if (!code.trim()) {
-            return false;
-        }
-        const ARROW_FUNCTION_PATTERN = /^\s*\([^)]*\)\s*=>/;
-        return ARROW_FUNCTION_PATTERN.test(code);
-    }
-    /**
-   * export default 표현식에서 ObjectLiteralExpression 추출
-   * - as const 처리
-   * - defineLocale({ ... }) 호출 처리
-   */ unwrapToObjectLiteral(expr) {
-        // as const 처리
-        if (ts.isAsExpression(expr)) {
-            return this.unwrapToObjectLiteral(expr.expression);
-        }
-        // 직접 객체 리터럴
-        if (ts.isObjectLiteralExpression(expr)) {
-            return expr;
-        }
-        // defineLocale({ ... }) 호출
-        if (ts.isCallExpression(expr)) {
-            const firstArg = expr.arguments[0];
-            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                return firstArg;
-            }
-        }
-        return null;
-    }
-    /**
-   * ObjectLiteralExpression에서 DictEntry 추출
-   */ extractEntriesFromObject(objectLiteral, sourceFile, entries) {
-        for (const prop of objectLiteral.properties){
-            const entry = this.extractDictEntry(prop, sourceFile);
-            if (entry) {
-                entries.push(entry);
-            }
-        }
-    }
-    /**
-   * PropertyName에서 키 문자열 추출
-   * - 문자열 리터럴: "key"
-   * - 식별자: key (unquoted)
-   */ getPropertyKey(name) {
-        if (ts.isStringLiteral(name)) {
-            return name.text;
-        }
-        if (ts.isIdentifier(name)) {
-            return name.text;
-        }
-        return null;
-    }
-    /**
-   * 프로퍼티에서 DictEntry 추출
-   * - 문자열: 실제 문자열 값
-   * - 함수: 원본 소스 (여러 줄은 한 줄로 정규화)
-   */ extractDictEntry(prop, sourceFile) {
-        if (!ts.isPropertyAssignment(prop)) {
-            return null;
-        }
-        const key = this.getPropertyKey(prop.name);
-        if (!key) return null;
-        const init = prop.initializer;
-        // 화살표 함수
-        if (ts.isArrowFunction(init)) {
-            const funcText = init.getText(sourceFile);
-            const normalized = funcText.replace(/\s*\n\s*/g, " ").trim();
-            return {
-                key,
-                value: normalized,
-                isFunction: true
-            };
-        }
-        // 문자열 리터럴
-        if (ts.isStringLiteral(init)) {
-            return {
-                key,
-                value: init.text,
-                isFunction: false
-            };
-        }
-        // 템플릿 리터럴 (변수 없음)
-        if (ts.isNoSubstitutionTemplateLiteral(init)) {
-            return {
-                key,
-                value: init.text,
-                isFunction: false
-            };
-        }
-        // 기타 (예: 함수 표현식)
-        return {
-            key,
-            value: init.getText(sourceFile),
-            isFunction: ts.isFunctionExpression(init)
-        };
-    }
-    /**
-   * 프로젝트의 i18n dict 파일 경로를 반환합니다.
-   * @param locale - 로케일 (ko, en 등)
-   * @param target - 타겟 디렉토리 (api, web, app)
-   */ getProjectDictPath(locale, target = "api") {
-        const dir = target === "api" ? Sonamu.config.api.dir : target;
-        return path.join(Sonamu.appRootPath, dir, "src", "i18n", `${locale}.ts`);
-    }
-    /**
-   * sonamu 내장 dict 파일 경로를 반환합니다.
-   */ getSonamuDictPath(locale) {
-        const packageRoot = path.resolve(import.meta.dirname, "..", "..");
-        return path.join(packageRoot, "src", "dict", `${locale}.ts`);
-    }
-    /**
-   * 필요한 dict 키가 프로젝트에 존재하는지 확인하고, 없으면 추가합니다.
-   * defaultLocale에만 추가하며, 다른 locale은 사용자가 직접 번역해야 합니다.
-   *
-   * @param requiredKeys - 필요한 키 목록
-   * @param target - 타겟 디렉토리 (api, web, app)
-   * @returns 추가된 키 목록
-   */ async ensureDictKeys(requiredKeys, target = "api") {
-        const { defaultLocale } = Sonamu.config.i18n;
-        const projectDictPath = this.getProjectDictPath(defaultLocale, target);
-        // 프로젝트 dict 파일이 없으면 아무것도 하지 않음
-        if (!fs.existsSync(projectDictPath)) {
-            return [];
-        }
-        // 프로젝트 dict에서 기존 키 파싱
-        const projectEntries = this.parseDictFile(projectDictPath);
-        const existingKeys = new Set(projectEntries.map((e)=>e.key));
-        // 누락된 키 찾기
-        const missingKeys = requiredKeys.filter((key)=>!existingKeys.has(key));
-        if (missingKeys.length === 0) {
-            return [];
-        }
-        // sonamu dict에서 기본값 가져오기
-        const sonamuDictPath = this.getSonamuDictPath(defaultLocale);
-        if (!fs.existsSync(sonamuDictPath)) {
-            return [];
-        }
-        const sonamuEntries = this.parseDictFile(sonamuDictPath);
-        const sonamuDict = new Map(sonamuEntries.map((e)=>[
-                e.key,
-                e
-            ]));
-        // 추가할 엔트리 생성
-        const entriesToAdd = missingKeys.map((key)=>sonamuDict.get(key)).filter((entry)=>entry !== undefined);
-        if (entriesToAdd.length === 0) {
-            return [];
-        }
-        // 프로젝트 dict 파일에 추가
-        await this.appendEntriesToDictFile(projectDictPath, entriesToAdd, defaultLocale, true);
-        return entriesToAdd.map((e)=>e.key);
-    }
-    /**
-   * dict 파일에 엔트리를 추가합니다.
-   * 기존 파일을 파싱하고, 새 엔트리를 추가한 뒤, 전체 파일을 재생성합니다.
-   */ async appendEntriesToDictFile(filePath, entries, locale, isDefaultLocale) {
-        // 기존 entries 파싱
-        const existingEntries = this.parseDictFile(filePath);
-        // 새 entries 추가
-        for (const entry of entries){
-            existingEntries.push(entry);
-        }
-        // 파일 재생성
-        const content = this.generateProjectDict(locale, existingEntries, isDefaultLocale);
-        const formatted = formatCode(content, "typescript", filePath);
-        fs.writeFileSync(filePath, formatted, "utf-8");
-    }
-    /**
-   * 함수 값들에서 사용되는 헬퍼 함수를 감지합니다.
-   */ detectUsedHelpers(entries) {
-        const functionEntries = entries.filter((e)=>e.isFunction);
-        const helpers = [];
-        for (const helper of [
-            "plural",
-            "josa"
-        ]){
-            // 함수명이 단어 경계로 사용되는지 확인 (예: plural( 또는 plural,)
-            const pattern = new RegExp(`\\b${helper}\\s*\\(`);
-            if (functionEntries.some((e)=>pattern.test(e.value))) {
-                helpers.push(helper);
-            }
-        }
-        // format 사용 여부 별도 감지 (format.number(...), format.date(...) 등)
-        const formatPattern = /\bformat\.\w+\s*\(/;
-        const usesFormat = functionEntries.some((e)=>formatPattern.test(e.value));
-        return {
-            helpers,
-            usesFormat
-        };
-    }
-    /**
-   * Project dict 파일 생성
-   */ generateProjectDict(locale, entries, isDefaultLocale) {
-        // key 알파벳 순 정렬
-        const sorted = [
-            ...entries
-        ].sort((a, b)=>a.key.localeCompare(b.key));
-        const lines = [];
-        // 함수 값에서 사용되는 헬퍼 함수 감지
-        const { helpers, usesFormat } = this.detectUsedHelpers(entries);
-        // 헬퍼 함수 import 추가
-        const imports = [
-            ...helpers
-        ];
-        if (usesFormat) {
-            imports.push("createFormat");
-        }
-        if (imports.length > 0) {
-            lines.push(`import { ${imports.join(", ")} } from "sonamu/dict";`);
-        }
-        if (!isDefaultLocale) {
-            lines.push('import { defineLocale } from "./sd.generated";');
-        }
-        if (imports.length > 0 || !isDefaultLocale) {
-            lines.push("");
-        }
-        // format 사용 시 createFormat 호출 추가
-        if (usesFormat) {
-            lines.push(`const format = createFormat("${locale}");`);
-            lines.push("");
-        }
-        lines.push("/**");
-        lines.push(` * Project ${locale.toUpperCase()} Dictionary`);
-        lines.push(" */");
-        if (isDefaultLocale) {
-            lines.push("export default {");
-        } else {
-            lines.push("export default defineLocale({");
-        }
-        for (const entry of sorted){
-            if (entry.isFunction) {
-                // 함수인 경우: 원형 그대로 출력
-                lines.push(`  "${entry.key}": ${entry.value},`);
-            } else {
-                lines.push(`  "${entry.key}": ${JSON.stringify(entry.value)},`);
-            }
-        }
-        if (isDefaultLocale) {
-            lines.push("} as const;");
-        } else {
-            lines.push("});");
-        }
-        lines.push("");
-        return lines.join("\n");
-    }
-    /**
-   * i18n 설정을 가져옵니다.
-   */ getI18nConfig() {
-        return Sonamu.config.i18n;
-    }
-    /**
-   * i18n 디렉토리 경로를 반환하고, 없으면 생성합니다.
-   */ ensureI18nDir() {
-        const i18nDir = path.join(Sonamu.apiRootPath, "src", "i18n");
-        if (!fs.existsSync(i18nDir)) {
-            fs.mkdirSync(i18nDir, {
-                recursive: true
-            });
-        }
-        return i18nDir;
-    }
-    /**
-   * dict 파일을 저장합니다.
-   */ saveDictFile(locale, entries, isDefaultLocale) {
-        const i18nDir = this.ensureI18nDir();
-        const dictPath = path.join(i18nDir, `${locale}.ts`);
-        const content = this.generateProjectDict(locale, entries, isDefaultLocale);
-        const formatted = formatCode(content, "typescript", dictPath);
-        fs.writeFileSync(dictPath, formatted, "utf-8");
-    }
-    /**
-   * i18n key를 파싱하여 entity 관련 정보 추출
-   */ parseEntityKey(key) {
-        // entity.{EntityId} (list, create, edit 제외)
-        const entityTitleMatch = key.match(/^entity\.([A-Z][a-zA-Z0-9]*)$/);
-        if (entityTitleMatch && !key.includes(".list") && !key.includes(".create") && !key.includes(".edit")) {
-            return {
-                type: "entityTitle",
-                entityId: entityTitleMatch[1]
-            };
-        }
-        // entity.{EntityId}.{propName}
-        const propDescMatch = key.match(/^entity\.([A-Z][a-zA-Z0-9]*)\.([a-z_][a-z0-9_]*)$/);
-        if (propDescMatch) {
-            return {
-                type: "propDesc",
-                entityId: propDescMatch[1],
-                propName: propDescMatch[2]
-            };
-        }
-        // enum.{EnumId}.{value}
-        const enumLabelMatch = key.match(/^enum\.([A-Z][a-zA-Z0-9]*)\.(.+)$/);
-        if (enumLabelMatch) {
-            return {
-                type: "enumLabel",
-                enumId: enumLabelMatch[1],
-                enumValue: enumLabelMatch[2]
-            };
-        }
-        return {
-            type: "other"
-        };
-    }
-    /**
-   * entity key에 대해 entity.json 업데이트 수행
-   * @returns 업데이트 여부
-   */ async updateEntityByKey(key, value) {
-        const keyInfo = this.parseEntityKey(key);
-        switch(keyInfo.type){
-            case "entityTitle":
-                {
-                    try {
-                        const entity = EntityManager.get(keyInfo.entityId);
-                        if (entity.title !== value) {
-                            entity.title = value;
-                            await entity.save();
-                            return true;
-                        }
-                    } catch  {
-                    // entity not found
-                    }
-                    return false;
-                }
-            case "propDesc":
-                {
-                    try {
-                        const entity = EntityManager.get(keyInfo.entityId);
-                        const propIndex = entity.props.findIndex((p)=>p.name === keyInfo.propName);
-                        if (propIndex !== -1 && entity.props[propIndex].desc !== value) {
-                            entity.props[propIndex].desc = value;
-                            await entity.save();
-                            return true;
-                        }
-                    } catch  {
-                    // entity not found
-                    }
-                    return false;
-                }
-            case "enumLabel":
-                {
-                    for (const entityId of EntityManager.getAllIds()){
-                        const entity = EntityManager.get(entityId);
-                        if (entity.enumLabels[keyInfo.enumId]) {
-                            if (entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] !== value) {
-                                entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] = value;
-                                await entity.save();
-                                return true;
-                            }
-                            break;
-                        }
-                    }
-                    return false;
-                }
-            default:
-                return false;
-        }
-    }
-    /**
-   * sd.generated.ts에서 entity labels 추출
-   * entity.json에서 관리되는 값만 포함 (.list, .create, .edit 제외)
-   */ extractEntityLabels() {
-        const sdPath = path.join(Sonamu.apiRootPath, "src", "i18n", "sd.generated.ts");
-        if (!fs.existsSync(sdPath)) {
-            return [];
-        }
-        return this.parseConstObjectDeclaration(sdPath, "entityLabels");
-    }
-    /**
-   * sd.generated.ts에서 rc-keys 추출
-   * react-components에서 관리되는 i18n 키들
-   * @param locale - 로케일 (ko, en 등)
-   */ extractRCKeys(locale) {
-        const sdPath = path.join(Sonamu.apiRootPath, "src", "i18n", "sd.generated.ts");
-        if (!fs.existsSync(sdPath)) {
-            return [];
-        }
-        // locale별 변수명 매핑 (sd.template.ts의 getRCKeysVarName과 동일)
-        const varName = (()=>{
-            if (locale === "ko") return "rcKeysKo";
-            if (locale === "en") return "rcKeysEn";
-            // 다른 locale은 en을 fallback으로 사용
-            return "rcKeysEn";
-        })();
-        return this.parseConstObjectDeclaration(sdPath, varName);
-    }
-    /**
-   * Project dict 파일([locale].ts)에서 딕셔너리 로드
-   */ loadProjectDict(locale) {
-        const dictPath = path.join(Sonamu.apiRootPath, "src", "i18n", `${locale}.ts`);
-        if (!fs.existsSync(dictPath)) {
-            return {
-                entries: []
-            };
-        }
-        return {
-            entries: this.parseDictFile(dictPath)
-        };
-    }
-    /**
-   * 딕셔너리 데이터 수집 (sonamu + entity + project)
-   */ async collectDictionary() {
-        const { defaultLocale, supportedLocales } = this.getI18nConfig();
-        const locales = supportedLocales;
-        const rows = [];
-        const rowMap = new Map();
-        // 1. RC Keys (sonamu source, 각 locale별)
-        for (const locale of locales){
-            const rcKeys = this.extractRCKeys(locale);
-            for (const rcKey of rcKeys){
-                let row = rowMap.get(rcKey.key);
-                if (!row) {
-                    row = {
-                        key: rcKey.key,
-                        source: "sonamu",
-                        isFunction: rcKey.isFunction ?? false
-                    };
-                    rowMap.set(rcKey.key, row);
-                }
-                row[locale] = rcKey.value;
-                if (rcKey.isFunction) {
-                    row.isFunction = true;
-                }
-            }
-        }
-        // 2. Entity labels (default locale 기준)
-        const entityLabels = this.extractEntityLabels();
-        for (const label of entityLabels){
-            const row = {
-                key: label.key,
-                source: "entity",
-                isFunction: label.isFunction ?? false,
-                [defaultLocale]: label.value
-            };
-            rowMap.set(label.key, row);
-        }
-        // 3. Project dict (각 locale별)
-        for (const locale of locales){
-            const { entries } = this.loadProjectDict(locale);
-            for (const entry of entries){
-                const existing = rowMap.get(entry.key);
-                if (existing) {
-                    // sonamu, entity source가 있으면 해당 locale 값만 추가
-                    existing[locale] = entry.value;
-                    if (entry.isFunction) {
-                        existing.isFunction = true;
-                    }
-                } else {
-                    // project source로 새로 추가
-                    let row = rowMap.get(entry.key);
-                    if (!row) {
-                        row = {
-                            key: entry.key,
-                            source: "project",
-                            isFunction: entry.isFunction
-                        };
-                        rowMap.set(entry.key, row);
-                    }
-                    row[locale] = entry.value;
-                }
-            }
-        }
-        rows.push(...rowMap.values());
-        rows.sort((a, b)=>a.key.localeCompare(b.key));
-        // 통계 계산: locale별 (채워진 값 / 전체 키 수)
-        const stats = {};
-        const total = rows.length;
-        for (const locale of locales){
-            const filled = rows.filter((row)=>row[locale] != null && row[locale] !== "").length;
-            const percent = total > 0 ? Math.round(filled / total * 100) : 0;
-            stats[locale] = {
-                total,
-                filled,
-                percent
-            };
-        }
-        return {
-            rows,
-            locales,
-            defaultLocale,
-            stats
-        };
-    }
-    /**
-   * 딕셔너리 조회
-   */ async getDictionary() {
-        return this.collectDictionary();
-    }
-    /**
-   * Excel로 내보내기
-   */ async exportToExcel() {
-        const { rows, locales } = await this.collectDictionary();
-        const wb = new Workbook();
-        const sheet = "i18n";
-        wb.setSheetName("Sheet1", sheet);
-        const projectName = `${Sonamu.config.projectName ?? "Sonamu"} Dictionary`;
-        const headers = [
-            "key",
-            "source",
-            ...locales
-        ];
-        // 스타일 정의
-        const titleStyleId = wb.addStyle({
-            font: {
-                size: 23
-            },
-            alignment: {
-                vertical: "center",
-                horizontal: "left"
-            }
-        });
-        const headerStyleId = wb.addStyle({
-            font: {
-                bold: true,
-                size: 11
-            },
-            alignment: {
-                horizontal: "center",
-                vertical: "center"
-            },
-            fill: {
-                pattern: "solid",
-                fgColor: "F1F1F1"
-            },
-            border: {
-                top: {
-                    style: "thin",
-                    color: "D0D0D0"
-                },
-                left: {
-                    style: "thin",
-                    color: "D0D0D0"
-                },
-                bottom: {
-                    style: "thin",
-                    color: "D0D0D0"
-                },
-                right: {
-                    style: "thin",
-                    color: "D0D0D0"
-                }
-            }
-        });
-        const dataStyleId = wb.addStyle({
-            font: {
-                size: 11
-            },
-            alignment: {
-                vertical: "center",
-                horizontal: "left"
-            }
-        });
-        // 행 1: 프로젝트명
-        wb.setCellValue(sheet, "A1", projectName);
-        wb.setCellStyle(sheet, "A1", titleStyleId);
-        wb.setRowHeight(sheet, 1, 28);
-        // 행 2: 빈 행 (기본값)
-        // 행 3: 헤더
-        wb.setRowValues(sheet, 3, "A", headers);
-        wb.setRowHeight(sheet, 3, 26);
-        for(let col = 0; col < headers.length; col++){
-            wb.setCellStyle(sheet, `${colLetter(col)}3`, headerStyleId);
-        }
-        // 행 4 이후: 데이터
-        for(let i = 0; i < rows.length; i++){
-            const row = rows[i];
-            const values = [
-                row.key,
-                row.source,
-                ...locales.map((locale)=>row[locale] ?? "")
-            ];
-            const rowNum = i + 4;
-            wb.setRowValues(sheet, rowNum, "A", values);
-            wb.setRowHeight(sheet, rowNum, 24);
-            for(let col = 0; col < values.length; col++){
-                wb.setCellStyle(sheet, `${colLetter(col)}${rowNum}`, dataStyleId);
-            }
-        }
-        // 컬럼 너비 계산
-        const MAX_WIDTH = 50;
-        const MIN_WIDTH = 10;
-        const columnWidths = headers.map((header)=>Math.max(header.length, MIN_WIDTH));
-        for (const row of rows){
-            const values = [
-                row.key,
-                row.source,
-                ...locales.map((locale)=>row[locale] ?? "")
-            ];
-            values.forEach((value, idx)=>{
-                const textLength = String(value).length;
-                columnWidths[idx] = Math.min(Math.max(columnWidths[idx], textLength), MAX_WIDTH);
-            });
-        }
-        // 컬럼 너비 적용
-        for(let col = 0; col < columnWidths.length; col++){
-            wb.setColWidth(sheet, colLetter(col), columnWidths[col] + 2);
-        }
-        return {
-            filename: `${projectName}-${new Date().toISOString().split("T")[0]}.xlsx`,
-            buffer: wb.writeBufferSync()
-        };
-    }
-    /**
-   * Excel에서 가져오기
-   *
-   * 형식:
-   * - 1행: 프로젝트명
-   * - 2행: 빈 행
-   * - 3행: 헤더 (key, source, locales...)
-   * - 4행 이후: 데이터
-   */ async importFromExcel(buffer) {
-        const wb = Workbook.openBufferSync(buffer);
-        const sheet = wb.sheetNames[0];
-        const allRows = wb.getRows(sheet);
-        const { defaultLocale, supportedLocales } = this.getI18nConfig();
-        const locales = supportedLocales;
-        let updatedEntities = 0;
-        let updatedLocales = 0;
-        // locale별 project dict entries
-        const projectDictEntries = {};
-        for (const locale of locales){
-            projectDictEntries[locale] = [];
-        }
-        // 헤더 행 찾기: 첫 번째 컬럼(A)이 "key"인 행
-        let headerRowNum = 0;
-        for (const rowData of allRows){
-            const firstCell = rowData.cells.find((c)=>c.column === "A");
-            const firstCellValue = String(firstCell?.value ?? "").trim().toLowerCase();
-            if (firstCellValue === "key") {
-                headerRowNum = rowData.row;
-                break;
-            }
-        }
-        if (headerRowNum === 0) {
-            throw new BadRequestException(SD("sonamu.error.headerRowNotFound"));
-        }
-        // 헤더 행에서 컬럼 매핑 구성
-        const headerRowData = allRows.find((r)=>r.row === headerRowNum);
-        const colToHeader = new Map();
-        if (headerRowData) {
-            for (const cell of headerRowData.cells){
-                colToHeader.set(cell.column, String(cell.value ?? ""));
-            }
-        }
-        // 데이터 행 읽기 (헤더 다음 행부터)
-        for (const rowData of allRows){
-            if (rowData.row <= headerRowNum) continue;
-            const rowValues = {};
-            for (const cell of rowData.cells){
-                const headerName = colToHeader.get(cell.column);
-                if (headerName) {
-                    rowValues[headerName] = String(cell.value ?? "");
-                }
-            }
-            const key = rowValues.key;
-            const source = rowValues.source;
-            if (!key || !source) continue;
-            if (source === "entity") {
-                // entity source: default locale만 entity.json에 저장
-                const defaultValue = rowValues[defaultLocale];
-                if (defaultValue) {
-                    const updated = await this.updateEntityByKey(key, defaultValue);
-                    if (updated) {
-                        updatedEntities++;
-                    }
-                }
-                // non-default locale은 project dict에 저장
-                for (const locale of locales){
-                    if (locale === defaultLocale) continue;
-                    const cellValue = rowValues[locale]?.trim();
-                    if (cellValue) {
-                        projectDictEntries[locale].push({
-                            key,
-                            value: cellValue,
-                            isFunction: this.isExpressionFunction(cellValue)
-                        });
-                    }
-                }
-            } else if (source === "project") {
-                // project source: 모든 locale을 project dict에 저장
-                for (const locale of locales){
-                    const cellValue = rowValues[locale]?.trim();
-                    if (cellValue) {
-                        projectDictEntries[locale].push({
-                            key,
-                            value: cellValue,
-                            isFunction: this.isExpressionFunction(cellValue)
-                        });
-                    }
-                }
-            }
-        }
-        // Project dict 파일 생성
-        for (const locale of locales){
-            const entries = projectDictEntries[locale];
-            if (entries.length > 0) {
-                this.saveDictFile(locale, entries, locale === defaultLocale);
-                updatedLocales++;
-            }
-        }
-        return {
-            success: true,
-            updatedEntities,
-            updatedLocales
-        };
-    }
-    /**
-   * 딕셔너리 항목 수정
-   */ async updateEntry(params) {
-        const { oldKey, newKey, source, values } = params;
-        const { defaultLocale, supportedLocales } = this.getI18nConfig();
-        const locales = supportedLocales;
-        // entity source의 default locale 처리
-        if (source === "entity" && values[defaultLocale]) {
-            await this.updateEntityByKey(newKey, values[defaultLocale]);
-        }
-        // project dict 업데이트
-        // - entity의 non-default locale
-        // - project source의 모든 locale
-        // - sonamu source의 모든 locale (override)
-        for (const locale of locales){
-            // entity source의 default locale은 entity.json에서 처리했으므로 스킵
-            if (source === "entity" && locale === defaultLocale) continue;
-            const cellValue = values[locale]?.trim();
-            if (!cellValue) continue;
-            // 기존 dict 로드
-            const { entries } = this.loadProjectDict(locale);
-            // key 변경 시 기존 key 제거
-            if (oldKey !== newKey) {
-                const oldIndex = entries.findIndex((e)=>e.key === oldKey);
-                if (oldIndex !== -1) {
-                    entries.splice(oldIndex, 1);
-                }
-            }
-            // 새 값 업데이트 또는 추가
-            const existingIndex = entries.findIndex((e)=>e.key === newKey);
-            const newEntry = {
-                key: newKey,
-                value: cellValue,
-                isFunction: this.isExpressionFunction(cellValue)
-            };
-            if (existingIndex !== -1) {
-                entries[existingIndex] = newEntry;
-            } else {
-                entries.push(newEntry);
-            }
-            // dict 파일 저장
-            this.saveDictFile(locale, entries, locale === defaultLocale);
-        }
-    }
-    /**
-   * 딕셔너리 항목 추가
-   */ async createEntry(params) {
-        const { key, values } = params;
-        if (!key?.trim()) {
-            throw new BadRequestException(SD("sonamu.error.keyRequired"));
-        }
-        const { defaultLocale, supportedLocales } = this.getI18nConfig();
-        const locales = supportedLocales;
-        // 중복 키 체크
-        for (const locale of locales){
-            const { entries } = this.loadProjectDict(locale);
-            if (entries.some((e)=>e.key === key)) {
-                throw new BadRequestException(SD("sonamu.error.keyAlreadyExists")(key));
-            }
-        }
-        // 각 locale에 새 키 추가
-        for (const locale of locales){
-            const cellValue = values[locale]?.trim();
-            if (!cellValue) continue;
-            const { entries } = this.loadProjectDict(locale);
-            entries.push({
-                key,
-                value: cellValue,
-                isFunction: this.isExpressionFunction(cellValue)
-            });
-            this.saveDictFile(locale, entries, locale === defaultLocale);
-        }
-    }
-    /**
-   * 딕셔너리 항목 삭제
-   */ async deleteEntry(key) {
-        if (!key) {
-            throw new BadRequestException(SD("sonamu.error.keyRequired"));
-        }
-        const { defaultLocale, supportedLocales } = this.getI18nConfig();
-        const locales = supportedLocales;
-        let deleted = false;
-        for (const locale of locales){
-            const { entries } = this.loadProjectDict(locale);
-            const index = entries.findIndex((e)=>e.key === key);
-            if (index !== -1) {
-                entries.splice(index, 1);
-                deleted = true;
-                this.saveDictFile(locale, entries, locale === defaultLocale);
-            }
-        }
-        if (!deleted) {
-            throw new BadRequestException(SD("sonamu.error.keyNotFound")(key));
-        }
-    }
-    /**
-   * 미사용 키 검사 (ast-grep 사용)
-   */ async checkUsage(keys) {
-        // ast-grep 설치 확인
-        let sgPath = null;
-        try {
-            sgPath = execSync("which sg", {
-                encoding: "utf-8"
-            }).trim();
-        } catch  {
-            try {
-                sgPath = execSync("which ast-grep", {
-                    encoding: "utf-8"
-                }).trim();
-            } catch  {
-            // ast-grep not installed
-            }
-        }
-        if (!sgPath) {
-            return {
-                error: "ast-grep이 설치되어 있지 않습니다. brew install ast-grep 또는 npm install -g @ast-grep/cli로 설치해주세요.",
-                unusedKeys: []
-            };
-        }
-        const searchPaths = [];
-        for (const entry of [
-            "api",
-            "web",
-            "app"
-        ]){
-            const srcPath = path.join(Sonamu.appRootPath, entry, "src");
-            if (fs.existsSync(srcPath)) {
-                searchPaths.push(srcPath);
-            }
-        }
-        if (searchPaths.length === 0) {
-            return {
-                error: "검색할 src 디렉토리를 찾을 수 없습니다.",
-                unusedKeys: []
-            };
-        }
-        const usedKeys = new Set();
-        try {
-            // ast-grep으로 SD("...") 패턴 검색
-            // 패턴: SD("KEY") 또는 SD('KEY') 형태
-            const patterns = [
-                'SD("$KEY")',
-                "SD('$KEY')"
-            ];
-            for (const searchPath of searchPaths){
-                for (const pattern of patterns){
-                    try {
-                        const result = execSync(`${sgPath} --pattern '${pattern}' --json ${searchPath}`, {
-                            encoding: "utf-8",
-                            maxBuffer: 50 * 1024 * 1024
-                        });
-                        if (result.trim()) {
-                            const matches = JSON.parse(result);
-                            for (const match of matches){
-                                // metaVariables.single.KEY.text에서 키 추출
-                                const keyText = match.metaVariables?.single?.KEY?.text;
-                                if (keyText) {
-                                    // 따옴표 제거
-                                    const cleanKey = keyText.replace(/^["']|["']$/g, "");
-                                    usedKeys.add(cleanKey);
-                                }
-                            }
-                        }
-                    } catch  {
-                    // 패턴 매치 없으면 에러 (무시)
-                    }
-                }
-            }
-            // keys 중에서 usedKeys에 없는 것들이 미사용 키
-            const unusedKeys = keys.filter((k)=>!usedKeys.has(k));
-            return {
-                unusedKeys,
-                usedKeysCount: usedKeys.size
-            };
-        } catch (e) {
-            return {
-                error: `검색 중 오류 발생: ${e instanceof Error ? e.message : String(e)}`,
-                unusedKeys: []
-            };
-        }
-    }
+* 0-based 컬럼 인덱스를 엑셀 컬럼 문자로 변환 (0 -> "A", 25 -> "Z", 26 -> "AA")
+*/
+function colLetter(index) {
+	let result = "";
+	let n = index;
+	while (n >= 0) {
+		result = String.fromCharCode(65 + n % 26) + result;
+		n = Math.floor(n / 26) - 1;
+	}
+	return result;
 }
-export const sonamuDictionary = new SonamuDictionary();
+var SonamuDictionary, sonamuDictionary;
+var init_sonamu_dictionary = __esmMin((() => {
+	init_sonamu();
+	init_entity_manager();
+	init_so_exceptions();
+	init_formatter();
+	init_sd();
+	SonamuDictionary = class {
+		/**
+		* TypeScript Compiler API를 사용하여 dict 파일 파싱
+		*
+		* 지원 패턴:
+		* - export default { ... } as const;
+		* - export default defineLocale({ ... });
+		* - 문자열 값: "key": "value" 또는 key: `value`
+		* - 함수 값: "key": (param: Type) => `template`
+		*/
+		parseDictFile(filePath) {
+			const content = fs.readFileSync(filePath, "utf-8");
+			const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+			const entries = [];
+			ts.forEachChild(sourceFile, (node) => {
+				if (ts.isExportAssignment(node)) {
+					const objectLiteral = this.unwrapToObjectLiteral(node.expression);
+					if (objectLiteral) {
+						this.extractEntriesFromObject(objectLiteral, sourceFile, entries);
+					}
+				}
+			});
+			return entries;
+		}
+		/**
+		* 파일에서 특정 이름의 const 선언을 찾아 ObjectLiteral 파싱
+		* 예: const entityLabels = { ... } as const;
+		*/
+		parseConstObjectDeclaration(filePath, varName) {
+			const content = fs.readFileSync(filePath, "utf-8");
+			const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+			const entries = [];
+			ts.forEachChild(sourceFile, (node) => {
+				if (ts.isVariableStatement(node)) {
+					for (const decl of node.declarationList.declarations) {
+						if (ts.isIdentifier(decl.name) && decl.name.text === varName && decl.initializer) {
+							const objectLiteral = this.unwrapToObjectLiteral(decl.initializer);
+							if (objectLiteral) {
+								this.extractEntriesFromObject(objectLiteral, sourceFile, entries);
+							}
+						}
+					}
+				}
+			});
+			return entries;
+		}
+		/**
+		* 문자열이 화살표 함수 또는 함수 표현식인지 판별
+		*/
+		isExpressionFunction(code) {
+			if (!code.trim()) {
+				return false;
+			}
+			const ARROW_FUNCTION_PATTERN = /^\s*\([^)]*\)\s*=>/;
+			return ARROW_FUNCTION_PATTERN.test(code);
+		}
+		/**
+		* export default 표현식에서 ObjectLiteralExpression 추출
+		* - as const 처리
+		* - defineLocale({ ... }) 호출 처리
+		*/
+		unwrapToObjectLiteral(expr) {
+			if (ts.isAsExpression(expr)) {
+				return this.unwrapToObjectLiteral(expr.expression);
+			}
+			if (ts.isObjectLiteralExpression(expr)) {
+				return expr;
+			}
+			if (ts.isCallExpression(expr)) {
+				const firstArg = expr.arguments[0];
+				if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+					return firstArg;
+				}
+			}
+			return null;
+		}
+		/**
+		* ObjectLiteralExpression에서 DictEntry 추출
+		*/
+		extractEntriesFromObject(objectLiteral, sourceFile, entries) {
+			for (const prop of objectLiteral.properties) {
+				const entry = this.extractDictEntry(prop, sourceFile);
+				if (entry) {
+					entries.push(entry);
+				}
+			}
+		}
+		/**
+		* PropertyName에서 키 문자열 추출
+		* - 문자열 리터럴: "key"
+		* - 식별자: key (unquoted)
+		*/
+		getPropertyKey(name) {
+			if (ts.isStringLiteral(name)) {
+				return name.text;
+			}
+			if (ts.isIdentifier(name)) {
+				return name.text;
+			}
+			return null;
+		}
+		/**
+		* 프로퍼티에서 DictEntry 추출
+		* - 문자열: 실제 문자열 값
+		* - 함수: 원본 소스 (여러 줄은 한 줄로 정규화)
+		*/
+		extractDictEntry(prop, sourceFile) {
+			if (!ts.isPropertyAssignment(prop)) {
+				return null;
+			}
+			const key = this.getPropertyKey(prop.name);
+			if (!key) return null;
+			const init = prop.initializer;
+			if (ts.isArrowFunction(init)) {
+				const funcText = init.getText(sourceFile);
+				const normalized = funcText.replace(/\s*\n\s*/g, " ").trim();
+				return {
+					key,
+					value: normalized,
+					isFunction: true
+				};
+			}
+			if (ts.isStringLiteral(init)) {
+				return {
+					key,
+					value: init.text,
+					isFunction: false
+				};
+			}
+			if (ts.isNoSubstitutionTemplateLiteral(init)) {
+				return {
+					key,
+					value: init.text,
+					isFunction: false
+				};
+			}
+			return {
+				key,
+				value: init.getText(sourceFile),
+				isFunction: ts.isFunctionExpression(init)
+			};
+		}
+		/**
+		* 프로젝트의 i18n dict 파일 경로를 반환합니다.
+		* @param locale - 로케일 (ko, en 등)
+		* @param target - 타겟 디렉토리 (api, web, app)
+		*/
+		getProjectDictPath(locale, target = "api") {
+			const dir = target === "api" ? Sonamu.config.api.dir : target;
+			return path.join(Sonamu.appRootPath, dir, "src", "i18n", `${locale}.ts`);
+		}
+		/**
+		* sonamu 내장 dict 파일 경로를 반환합니다.
+		*/
+		getSonamuDictPath(locale) {
+			const packageRoot = path.resolve(import.meta.dirname, "..", "..");
+			return path.join(packageRoot, "src", "dict", `${locale}.ts`);
+		}
+		/**
+		* 필요한 dict 키가 프로젝트에 존재하는지 확인하고, 없으면 추가합니다.
+		* defaultLocale에만 추가하며, 다른 locale은 사용자가 직접 번역해야 합니다.
+		*
+		* @param requiredKeys - 필요한 키 목록
+		* @param target - 타겟 디렉토리 (api, web, app)
+		* @returns 추가된 키 목록
+		*/
+		async ensureDictKeys(requiredKeys, target = "api") {
+			const { defaultLocale } = Sonamu.config.i18n;
+			const projectDictPath = this.getProjectDictPath(defaultLocale, target);
+			if (!fs.existsSync(projectDictPath)) {
+				return [];
+			}
+			const projectEntries = this.parseDictFile(projectDictPath);
+			const existingKeys = new Set(projectEntries.map((e) => e.key));
+			const missingKeys = requiredKeys.filter((key) => !existingKeys.has(key));
+			if (missingKeys.length === 0) {
+				return [];
+			}
+			const sonamuDictPath = this.getSonamuDictPath(defaultLocale);
+			if (!fs.existsSync(sonamuDictPath)) {
+				return [];
+			}
+			const sonamuEntries = this.parseDictFile(sonamuDictPath);
+			const sonamuDict = new Map(sonamuEntries.map((e) => [e.key, e]));
+			const entriesToAdd = missingKeys.map((key) => sonamuDict.get(key)).filter((entry) => entry !== undefined);
+			if (entriesToAdd.length === 0) {
+				return [];
+			}
+			await this.appendEntriesToDictFile(projectDictPath, entriesToAdd, defaultLocale, true);
+			return entriesToAdd.map((e) => e.key);
+		}
+		/**
+		* dict 파일에 엔트리를 추가합니다.
+		* 기존 파일을 파싱하고, 새 엔트리를 추가한 뒤, 전체 파일을 재생성합니다.
+		*/
+		async appendEntriesToDictFile(filePath, entries, locale, isDefaultLocale) {
+			const existingEntries = this.parseDictFile(filePath);
+			for (const entry of entries) {
+				existingEntries.push(entry);
+			}
+			const content = this.generateProjectDict(locale, existingEntries, isDefaultLocale);
+			const formatted = await formatCode(content, "typescript", filePath);
+			fs.writeFileSync(filePath, formatted, "utf-8");
+		}
+		/**
+		* 함수 값들에서 사용되는 헬퍼 함수를 감지합니다.
+		*/
+		detectUsedHelpers(entries) {
+			const functionEntries = entries.filter((e) => e.isFunction);
+			const helpers = [];
+			for (const helper of ["plural", "josa"]) {
+				const pattern = new RegExp(`\\b${helper}\\s*\\(`);
+				if (functionEntries.some((e) => pattern.test(e.value))) {
+					helpers.push(helper);
+				}
+			}
+			const formatPattern = /\bformat\.\w+\s*\(/;
+			const usesFormat = functionEntries.some((e) => formatPattern.test(e.value));
+			return {
+				helpers,
+				usesFormat
+			};
+		}
+		/**
+		* Project dict 파일 생성
+		*/
+		generateProjectDict(locale, entries, isDefaultLocale) {
+			const sorted = [...entries].toSorted((a, b) => a.key.localeCompare(b.key));
+			const lines = [];
+			const { helpers, usesFormat } = this.detectUsedHelpers(entries);
+			const imports = [...helpers];
+			if (usesFormat) {
+				imports.push("createFormat");
+			}
+			if (imports.length > 0) {
+				lines.push(`import { ${imports.join(", ")} } from "sonamu/dict";`);
+			}
+			if (!isDefaultLocale) {
+				lines.push("import { defineLocale } from \"./sd.generated\";");
+			}
+			if (imports.length > 0 || !isDefaultLocale) {
+				lines.push("");
+			}
+			if (usesFormat) {
+				lines.push(`const format = createFormat("${locale}");`);
+				lines.push("");
+			}
+			lines.push("/**");
+			lines.push(` * Project ${locale.toUpperCase()} Dictionary`);
+			lines.push(" */");
+			if (isDefaultLocale) {
+				lines.push("export default {");
+			} else {
+				lines.push("export default defineLocale({");
+			}
+			for (const entry of sorted) {
+				if (entry.isFunction) {
+					lines.push(`  "${entry.key}": ${entry.value},`);
+				} else {
+					lines.push(`  "${entry.key}": ${JSON.stringify(entry.value)},`);
+				}
+			}
+			if (isDefaultLocale) {
+				lines.push("} as const;");
+			} else {
+				lines.push("});");
+			}
+			lines.push("");
+			return lines.join("\n");
+		}
+		/**
+		* i18n 설정을 가져옵니다.
+		*/
+		getI18nConfig() {
+			return Sonamu.config.i18n;
+		}
+		/**
+		* i18n 디렉토리 경로를 반환하고, 없으면 생성합니다.
+		*/
+		ensureI18nDir() {
+			const i18nDir = path.join(Sonamu.apiRootPath, "src", "i18n");
+			if (!fs.existsSync(i18nDir)) {
+				fs.mkdirSync(i18nDir, { recursive: true });
+			}
+			return i18nDir;
+		}
+		/**
+		* dict 파일을 저장합니다.
+		*/
+		async saveDictFile(locale, entries, isDefaultLocale) {
+			const i18nDir = this.ensureI18nDir();
+			const dictPath = path.join(i18nDir, `${locale}.ts`);
+			const content = this.generateProjectDict(locale, entries, isDefaultLocale);
+			const formatted = await formatCode(content, "typescript", dictPath);
+			fs.writeFileSync(dictPath, formatted, "utf-8");
+		}
+		/**
+		* i18n key를 파싱하여 entity 관련 정보 추출
+		*/
+		parseEntityKey(key) {
+			const entityTitleMatch = key.match(/^entity\.([A-Z][a-zA-Z0-9]*)$/);
+			if (entityTitleMatch && !key.includes(".list") && !key.includes(".create") && !key.includes(".edit")) {
+				return {
+					type: "entityTitle",
+					entityId: entityTitleMatch[1]
+				};
+			}
+			const propDescMatch = key.match(/^entity\.([A-Z][a-zA-Z0-9]*)\.([a-z_][a-z0-9_]*)$/);
+			if (propDescMatch) {
+				return {
+					type: "propDesc",
+					entityId: propDescMatch[1],
+					propName: propDescMatch[2]
+				};
+			}
+			const enumLabelMatch = key.match(/^enum\.([A-Z][a-zA-Z0-9]*)\.(.+)$/);
+			if (enumLabelMatch) {
+				return {
+					type: "enumLabel",
+					enumId: enumLabelMatch[1],
+					enumValue: enumLabelMatch[2]
+				};
+			}
+			return { type: "other" };
+		}
+		/**
+		* entity key에 대해 entity.json 업데이트 수행
+		* @returns 업데이트 여부
+		*/
+		async updateEntityByKey(key, value) {
+			const keyInfo = this.parseEntityKey(key);
+			switch (keyInfo.type) {
+				case "entityTitle": {
+					try {
+						const entity = EntityManager.get(keyInfo.entityId);
+						if (entity.title !== value) {
+							entity.title = value;
+							await entity.save();
+							return true;
+						}
+					} catch {}
+					return false;
+				}
+				case "propDesc": {
+					try {
+						const entity = EntityManager.get(keyInfo.entityId);
+						const propIndex = entity.props.findIndex((p) => p.name === keyInfo.propName);
+						if (propIndex !== -1 && entity.props[propIndex].desc !== value) {
+							entity.props[propIndex].desc = value;
+							await entity.save();
+							return true;
+						}
+					} catch {}
+					return false;
+				}
+				case "enumLabel": {
+					for (const entityId of EntityManager.getAllIds()) {
+						const entity = EntityManager.get(entityId);
+						if (entity.enumLabels[keyInfo.enumId]) {
+							if (entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] !== value) {
+								entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] = value;
+								await entity.save();
+								return true;
+							}
+							break;
+						}
+					}
+					return false;
+				}
+				default: return false;
+			}
+		}
+		/**
+		* sd.generated.ts에서 entity labels 추출
+		* entity.json에서 관리되는 값만 포함 (.list, .create, .edit 제외)
+		*/
+		extractEntityLabels() {
+			const sdPath = path.join(Sonamu.apiRootPath, "src", "i18n", "sd.generated.ts");
+			if (!fs.existsSync(sdPath)) {
+				return [];
+			}
+			return this.parseConstObjectDeclaration(sdPath, "entityLabels");
+		}
+		/**
+		* sd.generated.ts에서 rc-keys 추출
+		* react-components에서 관리되는 i18n 키들
+		* @param locale - 로케일 (ko, en 등)
+		*/
+		extractRCKeys(locale) {
+			const sdPath = path.join(Sonamu.apiRootPath, "src", "i18n", "sd.generated.ts");
+			if (!fs.existsSync(sdPath)) {
+				return [];
+			}
+			const varName = (() => {
+				if (locale === "ko") return "rcKeysKo";
+				if (locale === "en") return "rcKeysEn";
+				return "rcKeysEn";
+			})();
+			return this.parseConstObjectDeclaration(sdPath, varName);
+		}
+		/**
+		* Project dict 파일([locale].ts)에서 딕셔너리 로드
+		*/
+		loadProjectDict(locale) {
+			const dictPath = path.join(Sonamu.apiRootPath, "src", "i18n", `${locale}.ts`);
+			if (!fs.existsSync(dictPath)) {
+				return { entries: [] };
+			}
+			return { entries: this.parseDictFile(dictPath) };
+		}
+		/**
+		* 딕셔너리 데이터 수집 (sonamu + entity + project)
+		*/
+		async collectDictionary() {
+			const { defaultLocale, supportedLocales } = this.getI18nConfig();
+			const locales = supportedLocales;
+			const rows = [];
+			const rowMap = new Map();
+			for (const locale of locales) {
+				const rcKeys = this.extractRCKeys(locale);
+				for (const rcKey of rcKeys) {
+					let row = rowMap.get(rcKey.key);
+					if (!row) {
+						row = {
+							key: rcKey.key,
+							source: "sonamu",
+							isFunction: rcKey.isFunction ?? false
+						};
+						rowMap.set(rcKey.key, row);
+					}
+					row[locale] = rcKey.value;
+					if (rcKey.isFunction) {
+						row.isFunction = true;
+					}
+				}
+			}
+			const entityLabels = this.extractEntityLabels();
+			for (const label of entityLabels) {
+				const row = {
+					key: label.key,
+					source: "entity",
+					isFunction: label.isFunction ?? false,
+					[defaultLocale]: label.value
+				};
+				rowMap.set(label.key, row);
+			}
+			for (const locale of locales) {
+				const { entries } = this.loadProjectDict(locale);
+				for (const entry of entries) {
+					const existing = rowMap.get(entry.key);
+					if (existing) {
+						existing[locale] = entry.value;
+						if (entry.isFunction) {
+							existing.isFunction = true;
+						}
+					} else {
+						let row = rowMap.get(entry.key);
+						if (!row) {
+							row = {
+								key: entry.key,
+								source: "project",
+								isFunction: entry.isFunction
+							};
+							rowMap.set(entry.key, row);
+						}
+						row[locale] = entry.value;
+					}
+				}
+			}
+			rows.push(...rowMap.values());
+			rows.sort((a, b) => a.key.localeCompare(b.key));
+			const stats = {};
+			const total = rows.length;
+			for (const locale of locales) {
+				const filled = rows.filter((row) => row[locale] != null && row[locale] !== "").length;
+				const percent = total > 0 ? Math.round(filled / total * 100) : 0;
+				stats[locale] = {
+					total,
+					filled,
+					percent
+				};
+			}
+			return {
+				rows,
+				locales,
+				defaultLocale,
+				stats
+			};
+		}
+		/**
+		* 딕셔너리 조회
+		*/
+		async getDictionary() {
+			return this.collectDictionary();
+		}
+		/**
+		* Excel로 내보내기
+		*/
+		async exportToExcel() {
+			const { rows, locales } = await this.collectDictionary();
+			const wb = new Workbook();
+			const sheet = "i18n";
+			wb.setSheetName("Sheet1", sheet);
+			const projectName = `${Sonamu.config.projectName ?? "Sonamu"} Dictionary`;
+			const headers = [
+				"key",
+				"source",
+				...locales
+			];
+			const titleStyleId = wb.addStyle({
+				font: { size: 23 },
+				alignment: {
+					vertical: "center",
+					horizontal: "left"
+				}
+			});
+			const headerStyleId = wb.addStyle({
+				font: {
+					bold: true,
+					size: 11
+				},
+				alignment: {
+					horizontal: "center",
+					vertical: "center"
+				},
+				fill: {
+					pattern: "solid",
+					fgColor: "F1F1F1"
+				},
+				border: {
+					top: {
+						style: "thin",
+						color: "D0D0D0"
+					},
+					left: {
+						style: "thin",
+						color: "D0D0D0"
+					},
+					bottom: {
+						style: "thin",
+						color: "D0D0D0"
+					},
+					right: {
+						style: "thin",
+						color: "D0D0D0"
+					}
+				}
+			});
+			const dataStyleId = wb.addStyle({
+				font: { size: 11 },
+				alignment: {
+					vertical: "center",
+					horizontal: "left"
+				}
+			});
+			wb.setCellValue(sheet, "A1", projectName);
+			wb.setCellStyle(sheet, "A1", titleStyleId);
+			wb.setRowHeight(sheet, 1, 28);
+			wb.setRowValues(sheet, 3, "A", headers);
+			wb.setRowHeight(sheet, 3, 26);
+			for (let col = 0; col < headers.length; col++) {
+				wb.setCellStyle(sheet, `${colLetter(col)}3`, headerStyleId);
+			}
+			for (let i = 0; i < rows.length; i++) {
+				const row = rows[i];
+				const values = [
+					row.key,
+					row.source,
+					...locales.map((locale) => row[locale] ?? "")
+				];
+				const rowNum = i + 4;
+				wb.setRowValues(sheet, rowNum, "A", values);
+				wb.setRowHeight(sheet, rowNum, 24);
+				for (let col = 0; col < values.length; col++) {
+					wb.setCellStyle(sheet, `${colLetter(col)}${rowNum}`, dataStyleId);
+				}
+			}
+			const MAX_WIDTH = 50;
+			const MIN_WIDTH = 10;
+			const columnWidths = headers.map((header) => Math.max(header.length, MIN_WIDTH));
+			for (const row of rows) {
+				const values = [
+					row.key,
+					row.source,
+					...locales.map((locale) => row[locale] ?? "")
+				];
+				values.forEach((value, idx) => {
+					const textLength = String(value).length;
+					columnWidths[idx] = Math.min(Math.max(columnWidths[idx], textLength), MAX_WIDTH);
+				});
+			}
+			for (let col = 0; col < columnWidths.length; col++) {
+				wb.setColWidth(sheet, colLetter(col), columnWidths[col] + 2);
+			}
+			return {
+				filename: `${projectName}-${new Date().toISOString().split("T")[0]}.xlsx`,
+				buffer: wb.writeBufferSync()
+			};
+		}
+		/**
+		* Excel에서 가져오기
+		*
+		* 형식:
+		* - 1행: 프로젝트명
+		* - 2행: 빈 행
+		* - 3행: 헤더 (key, source, locales...)
+		* - 4행 이후: 데이터
+		*/
+		async importFromExcel(buffer) {
+			const wb = Workbook.openBufferSync(buffer);
+			const sheet = wb.sheetNames[0];
+			const allRows = wb.getRows(sheet);
+			const { defaultLocale, supportedLocales } = this.getI18nConfig();
+			const locales = supportedLocales;
+			let updatedEntities = 0;
+			let updatedLocales = 0;
+			const projectDictEntries = {};
+			for (const locale of locales) {
+				projectDictEntries[locale] = [];
+			}
+			let headerRowNum = 0;
+			for (const rowData of allRows) {
+				const firstCell = rowData.cells.find((c) => c.column === "A");
+				const firstCellValue = String(firstCell?.value ?? "").trim().toLowerCase();
+				if (firstCellValue === "key") {
+					headerRowNum = rowData.row;
+					break;
+				}
+			}
+			if (headerRowNum === 0) {
+				throw new BadRequestException(SD("sonamu.error.headerRowNotFound"));
+			}
+			const headerRowData = allRows.find((r) => r.row === headerRowNum);
+			const colToHeader = new Map();
+			if (headerRowData) {
+				for (const cell of headerRowData.cells) {
+					colToHeader.set(cell.column, String(cell.value ?? ""));
+				}
+			}
+			for (const rowData of allRows) {
+				if (rowData.row <= headerRowNum) continue;
+				const rowValues = {};
+				for (const cell of rowData.cells) {
+					const headerName = colToHeader.get(cell.column);
+					if (headerName) {
+						rowValues[headerName] = String(cell.value ?? "");
+					}
+				}
+				const key = rowValues.key;
+				const source = rowValues.source;
+				if (!key || !source) continue;
+				if (source === "entity") {
+					const defaultValue = rowValues[defaultLocale];
+					if (defaultValue) {
+						const updated = await this.updateEntityByKey(key, defaultValue);
+						if (updated) {
+							updatedEntities++;
+						}
+					}
+					for (const locale of locales) {
+						if (locale === defaultLocale) continue;
+						const cellValue = rowValues[locale]?.trim();
+						if (cellValue) {
+							projectDictEntries[locale].push({
+								key,
+								value: cellValue,
+								isFunction: this.isExpressionFunction(cellValue)
+							});
+						}
+					}
+				} else if (source === "project") {
+					for (const locale of locales) {
+						const cellValue = rowValues[locale]?.trim();
+						if (cellValue) {
+							projectDictEntries[locale].push({
+								key,
+								value: cellValue,
+								isFunction: this.isExpressionFunction(cellValue)
+							});
+						}
+					}
+				}
+			}
+			for (const locale of locales) {
+				const entries = projectDictEntries[locale];
+				if (entries.length > 0) {
+					await this.saveDictFile(locale, entries, locale === defaultLocale);
+					updatedLocales++;
+				}
+			}
+			return {
+				success: true,
+				updatedEntities,
+				updatedLocales
+			};
+		}
+		/**
+		* 딕셔너리 항목 수정
+		*/
+		async updateEntry(params) {
+			const { oldKey, newKey, source, values } = params;
+			const { defaultLocale, supportedLocales } = this.getI18nConfig();
+			const locales = supportedLocales;
+			if (source === "entity" && values[defaultLocale]) {
+				await this.updateEntityByKey(newKey, values[defaultLocale]);
+			}
+			for (const locale of locales) {
+				if (source === "entity" && locale === defaultLocale) continue;
+				const cellValue = values[locale]?.trim();
+				if (!cellValue) continue;
+				const { entries } = this.loadProjectDict(locale);
+				if (oldKey !== newKey) {
+					const oldIndex = entries.findIndex((e) => e.key === oldKey);
+					if (oldIndex !== -1) {
+						entries.splice(oldIndex, 1);
+					}
+				}
+				const existingIndex = entries.findIndex((e) => e.key === newKey);
+				const newEntry = {
+					key: newKey,
+					value: cellValue,
+					isFunction: this.isExpressionFunction(cellValue)
+				};
+				if (existingIndex !== -1) {
+					entries[existingIndex] = newEntry;
+				} else {
+					entries.push(newEntry);
+				}
+				await this.saveDictFile(locale, entries, locale === defaultLocale);
+			}
+		}
+		/**
+		* 딕셔너리 항목 추가
+		*/
+		async createEntry(params) {
+			const { key, values } = params;
+			if (!key?.trim()) {
+				throw new BadRequestException(SD("sonamu.error.keyRequired"));
+			}
+			const { defaultLocale, supportedLocales } = this.getI18nConfig();
+			const locales = supportedLocales;
+			for (const locale of locales) {
+				const { entries } = this.loadProjectDict(locale);
+				if (entries.some((e) => e.key === key)) {
+					throw new BadRequestException(SD("sonamu.error.keyAlreadyExists")(key));
+				}
+			}
+			for (const locale of locales) {
+				const cellValue = values[locale]?.trim();
+				if (!cellValue) continue;
+				const { entries } = this.loadProjectDict(locale);
+				entries.push({
+					key,
+					value: cellValue,
+					isFunction: this.isExpressionFunction(cellValue)
+				});
+				await this.saveDictFile(locale, entries, locale === defaultLocale);
+			}
+		}
+		/**
+		* 딕셔너리 항목 삭제
+		*/
+		async deleteEntry(key) {
+			if (!key) {
+				throw new BadRequestException(SD("sonamu.error.keyRequired"));
+			}
+			const { defaultLocale, supportedLocales } = this.getI18nConfig();
+			const locales = supportedLocales;
+			let deleted = false;
+			for (const locale of locales) {
+				const { entries } = this.loadProjectDict(locale);
+				const index = entries.findIndex((e) => e.key === key);
+				if (index !== -1) {
+					entries.splice(index, 1);
+					deleted = true;
+					await this.saveDictFile(locale, entries, locale === defaultLocale);
+				}
+			}
+			if (!deleted) {
+				throw new BadRequestException(SD("sonamu.error.keyNotFound")(key));
+			}
+		}
+		/**
+		* 미사용 키 검사 (ast-grep 사용)
+		*/
+		async checkUsage(keys) {
+			let sgPath = null;
+			try {
+				sgPath = execSync("which sg", { encoding: "utf-8" }).trim();
+			} catch {
+				try {
+					sgPath = execSync("which ast-grep", { encoding: "utf-8" }).trim();
+				} catch {}
+			}
+			if (!sgPath) {
+				return {
+					error: "ast-grep이 설치되어 있지 않습니다. brew install ast-grep 또는 npm install -g @ast-grep/cli로 설치해주세요.",
+					unusedKeys: []
+				};
+			}
+			const searchPaths = [];
+			for (const entry of [
+				"api",
+				"web",
+				"app"
+			]) {
+				const srcPath = path.join(Sonamu.appRootPath, entry, "src");
+				if (fs.existsSync(srcPath)) {
+					searchPaths.push(srcPath);
+				}
+			}
+			if (searchPaths.length === 0) {
+				return {
+					error: "검색할 src 디렉토리를 찾을 수 없습니다.",
+					unusedKeys: []
+				};
+			}
+			const usedKeys = new Set();
+			try {
+				const patterns = ["SD(\"$KEY\")", "SD('$KEY')"];
+				for (const searchPath of searchPaths) {
+					for (const pattern of patterns) {
+						try {
+							const result = execSync(`${sgPath} --pattern '${pattern}' --json ${searchPath}`, {
+								encoding: "utf-8",
+								maxBuffer: 50 * 1024 * 1024
+							});
+							if (result.trim()) {
+								const matches = JSON.parse(result);
+								for (const match of matches) {
+									const keyText = match.metaVariables?.single?.KEY?.text;
+									if (keyText) {
+										const cleanKey = keyText.replace(/^["']|["']$/g, "");
+										usedKeys.add(cleanKey);
+									}
+								}
+							}
+						} catch {}
+					}
+				}
+				const unusedKeys = keys.filter((k) => !usedKeys.has(k));
+				return {
+					unusedKeys,
+					usedKeysCount: usedKeys.size
+				};
+			} catch (e) {
+				return {
+					error: `검색 중 오류 발생: ${e instanceof Error ? e.message : String(e)}`,
+					unusedKeys: []
+				};
+			}
+		}
+	};
+	sonamuDictionary = new SonamuDictionary();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dict/sonamu-dictionary.ts"],"sourcesContent":["import { Workbook } from \"@sheetkit/node\";\nimport { execSync } from \"child_process\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport ts from \"typescript\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { BadRequestException } from \"../exceptions/so-exceptions\";\nimport { formatCode } from \"../utils/formatter\";\nimport { SD } from \"./sd\";\nimport type {\n  DictEntry,\n  DictionaryResult,\n  DictionaryRow,\n  EntityKeyInfo,\n  I18nConfig,\n  ImportResult,\n  UsageResult,\n} from \"./types\";\n\n/**\n * 0-based 컬럼 인덱스를 엑셀 컬럼 문자로 변환 (0 -> \"A\", 25 -> \"Z\", 26 -> \"AA\")\n */\nfunction colLetter(index: number): string {\n  let result = \"\";\n  let n = index;\n  while (n >= 0) {\n    result = String.fromCharCode(65 + (n % 26)) + result;\n    n = Math.floor(n / 26) - 1;\n  }\n  return result;\n}\n\n/**\n * Sonamu Dictionary 관리 클래스\n * i18n 딕셔너리의 CRUD 및 Excel import/export를 담당합니다.\n */\nexport class SonamuDictionary {\n  /**\n   * TypeScript Compiler API를 사용하여 dict 파일 파싱\n   *\n   * 지원 패턴:\n   * - export default { ... } as const;\n   * - export default defineLocale({ ... });\n   * - 문자열 값: \"key\": \"value\" 또는 key: `value`\n   * - 함수 값: \"key\": (param: Type) => `template`\n   */\n  parseDictFile(filePath: string): DictEntry[] {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);\n\n    const entries: DictEntry[] = [];\n\n    ts.forEachChild(sourceFile, (node) => {\n      if (ts.isExportAssignment(node)) {\n        const objectLiteral = this.unwrapToObjectLiteral(node.expression);\n        if (objectLiteral) {\n          this.extractEntriesFromObject(objectLiteral, sourceFile, entries);\n        }\n      }\n    });\n\n    return entries;\n  }\n\n  /**\n   * 파일에서 특정 이름의 const 선언을 찾아 ObjectLiteral 파싱\n   * 예: const entityLabels = { ... } as const;\n   */\n  parseConstObjectDeclaration(filePath: string, varName: string): DictEntry[] {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);\n\n    const entries: DictEntry[] = [];\n\n    ts.forEachChild(sourceFile, (node) => {\n      if (ts.isVariableStatement(node)) {\n        for (const decl of node.declarationList.declarations) {\n          if (ts.isIdentifier(decl.name) && decl.name.text === varName && decl.initializer) {\n            const objectLiteral = this.unwrapToObjectLiteral(decl.initializer);\n            if (objectLiteral) {\n              this.extractEntriesFromObject(objectLiteral, sourceFile, entries);\n            }\n          }\n        }\n      }\n    });\n\n    return entries;\n  }\n\n  /**\n   * 문자열이 화살표 함수 또는 함수 표현식인지 판별\n   */\n  isExpressionFunction(code: string): boolean {\n    // 빈 문자열이나 공백만 있는 경우\n    if (!code.trim()) {\n      return false;\n    }\n\n    const ARROW_FUNCTION_PATTERN = /^\\s*\\([^)]*\\)\\s*=>/;\n\n    return ARROW_FUNCTION_PATTERN.test(code);\n  }\n\n  /**\n   * export default 표현식에서 ObjectLiteralExpression 추출\n   * - as const 처리\n   * - defineLocale({ ... }) 호출 처리\n   */\n  private unwrapToObjectLiteral(expr: ts.Expression): ts.ObjectLiteralExpression | null {\n    // as const 처리\n    if (ts.isAsExpression(expr)) {\n      return this.unwrapToObjectLiteral(expr.expression);\n    }\n    // 직접 객체 리터럴\n    if (ts.isObjectLiteralExpression(expr)) {\n      return expr;\n    }\n    // defineLocale({ ... }) 호출\n    if (ts.isCallExpression(expr)) {\n      const firstArg = expr.arguments[0];\n      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {\n        return firstArg;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * ObjectLiteralExpression에서 DictEntry 추출\n   */\n  private extractEntriesFromObject(\n    objectLiteral: ts.ObjectLiteralExpression,\n    sourceFile: ts.SourceFile,\n    entries: DictEntry[],\n  ): void {\n    for (const prop of objectLiteral.properties) {\n      const entry = this.extractDictEntry(prop, sourceFile);\n      if (entry) {\n        entries.push(entry);\n      }\n    }\n  }\n\n  /**\n   * PropertyName에서 키 문자열 추출\n   * - 문자열 리터럴: \"key\"\n   * - 식별자: key (unquoted)\n   */\n  private getPropertyKey(name: ts.PropertyName): string | null {\n    if (ts.isStringLiteral(name)) {\n      return name.text;\n    }\n    if (ts.isIdentifier(name)) {\n      return name.text;\n    }\n    return null;\n  }\n\n  /**\n   * 프로퍼티에서 DictEntry 추출\n   * - 문자열: 실제 문자열 값\n   * - 함수: 원본 소스 (여러 줄은 한 줄로 정규화)\n   */\n  private extractDictEntry(\n    prop: ts.ObjectLiteralElementLike,\n    sourceFile: ts.SourceFile,\n  ): DictEntry | null {\n    if (!ts.isPropertyAssignment(prop)) {\n      return null;\n    }\n\n    const key = this.getPropertyKey(prop.name);\n    if (!key) return null;\n\n    const init = prop.initializer;\n\n    // 화살표 함수\n    if (ts.isArrowFunction(init)) {\n      const funcText = init.getText(sourceFile);\n      const normalized = funcText.replace(/\\s*\\n\\s*/g, \" \").trim();\n      return { key, value: normalized, isFunction: true };\n    }\n\n    // 문자열 리터럴\n    if (ts.isStringLiteral(init)) {\n      return { key, value: init.text, isFunction: false };\n    }\n\n    // 템플릿 리터럴 (변수 없음)\n    if (ts.isNoSubstitutionTemplateLiteral(init)) {\n      return { key, value: init.text, isFunction: false };\n    }\n\n    // 기타 (예: 함수 표현식)\n    return {\n      key,\n      value: init.getText(sourceFile),\n      isFunction: ts.isFunctionExpression(init),\n    };\n  }\n\n  /**\n   * 프로젝트의 i18n dict 파일 경로를 반환합니다.\n   * @param locale - 로케일 (ko, en 등)\n   * @param target - 타겟 디렉토리 (api, web, app)\n   */\n  getProjectDictPath(locale: string, target: \"api\" | \"web\" | \"app\" = \"api\"): string {\n    const dir = target === \"api\" ? Sonamu.config.api.dir : target;\n    return path.join(Sonamu.appRootPath, dir, \"src\", \"i18n\", `${locale}.ts`);\n  }\n\n  /**\n   * sonamu 내장 dict 파일 경로를 반환합니다.\n   */\n  private getSonamuDictPath(locale: string): string {\n    const packageRoot = path.resolve(import.meta.dirname, \"..\", \"..\");\n    return path.join(packageRoot, \"src\", \"dict\", `${locale}.ts`);\n  }\n\n  /**\n   * 필요한 dict 키가 프로젝트에 존재하는지 확인하고, 없으면 추가합니다.\n   * defaultLocale에만 추가하며, 다른 locale은 사용자가 직접 번역해야 합니다.\n   *\n   * @param requiredKeys - 필요한 키 목록\n   * @param target - 타겟 디렉토리 (api, web, app)\n   * @returns 추가된 키 목록\n   */\n  async ensureDictKeys(\n    requiredKeys: string[],\n    target: \"api\" | \"web\" | \"app\" = \"api\",\n  ): Promise<string[]> {\n    const { defaultLocale } = Sonamu.config.i18n;\n    const projectDictPath = this.getProjectDictPath(defaultLocale, target);\n\n    // 프로젝트 dict 파일이 없으면 아무것도 하지 않음\n    if (!fs.existsSync(projectDictPath)) {\n      return [];\n    }\n\n    // 프로젝트 dict에서 기존 키 파싱\n    const projectEntries = this.parseDictFile(projectDictPath);\n    const existingKeys = new Set(projectEntries.map((e) => e.key));\n\n    // 누락된 키 찾기\n    const missingKeys = requiredKeys.filter((key) => !existingKeys.has(key));\n\n    if (missingKeys.length === 0) {\n      return [];\n    }\n\n    // sonamu dict에서 기본값 가져오기\n    const sonamuDictPath = this.getSonamuDictPath(defaultLocale);\n    if (!fs.existsSync(sonamuDictPath)) {\n      return [];\n    }\n\n    const sonamuEntries = this.parseDictFile(sonamuDictPath);\n    const sonamuDict = new Map(sonamuEntries.map((e) => [e.key, e]));\n\n    // 추가할 엔트리 생성\n    const entriesToAdd = missingKeys\n      .map((key) => sonamuDict.get(key))\n      .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);\n\n    if (entriesToAdd.length === 0) {\n      return [];\n    }\n\n    // 프로젝트 dict 파일에 추가\n    await this.appendEntriesToDictFile(projectDictPath, entriesToAdd, defaultLocale, true);\n\n    return entriesToAdd.map((e) => e.key);\n  }\n\n  /**\n   * dict 파일에 엔트리를 추가합니다.\n   * 기존 파일을 파싱하고, 새 엔트리를 추가한 뒤, 전체 파일을 재생성합니다.\n   */\n  private async appendEntriesToDictFile(\n    filePath: string,\n    entries: DictEntry[],\n    locale: string,\n    isDefaultLocale: boolean,\n  ): Promise<void> {\n    // 기존 entries 파싱\n    const existingEntries = this.parseDictFile(filePath);\n\n    // 새 entries 추가\n    for (const entry of entries) {\n      existingEntries.push(entry);\n    }\n\n    // 파일 재생성\n    const content = this.generateProjectDict(locale, existingEntries, isDefaultLocale);\n    const formatted = formatCode(content, \"typescript\", filePath);\n    fs.writeFileSync(filePath, formatted, \"utf-8\");\n  }\n\n  /**\n   * 함수 값들에서 사용되는 헬퍼 함수를 감지합니다.\n   */\n  private detectUsedHelpers(entries: DictEntry[]): {\n    helpers: string[];\n    usesFormat: boolean;\n  } {\n    const functionEntries = entries.filter((e) => e.isFunction);\n    const helpers: string[] = [];\n\n    for (const helper of [\"plural\", \"josa\"]) {\n      // 함수명이 단어 경계로 사용되는지 확인 (예: plural( 또는 plural,)\n      const pattern = new RegExp(`\\\\b${helper}\\\\s*\\\\(`);\n      if (functionEntries.some((e) => pattern.test(e.value))) {\n        helpers.push(helper);\n      }\n    }\n\n    // format 사용 여부 별도 감지 (format.number(...), format.date(...) 등)\n    const formatPattern = /\\bformat\\.\\w+\\s*\\(/;\n    const usesFormat = functionEntries.some((e) => formatPattern.test(e.value));\n\n    return { helpers, usesFormat };\n  }\n\n  /**\n   * Project dict 파일 생성\n   */\n  generateProjectDict(locale: string, entries: DictEntry[], isDefaultLocale: boolean): string {\n    // key 알파벳 순 정렬\n    const sorted = [...entries].sort((a, b) => a.key.localeCompare(b.key));\n\n    const lines: string[] = [];\n\n    // 함수 값에서 사용되는 헬퍼 함수 감지\n    const { helpers, usesFormat } = this.detectUsedHelpers(entries);\n\n    // 헬퍼 함수 import 추가\n    const imports = [...helpers];\n    if (usesFormat) {\n      imports.push(\"createFormat\");\n    }\n    if (imports.length > 0) {\n      lines.push(`import { ${imports.join(\", \")} } from \"sonamu/dict\";`);\n    }\n\n    if (!isDefaultLocale) {\n      lines.push('import { defineLocale } from \"./sd.generated\";');\n    }\n\n    if (imports.length > 0 || !isDefaultLocale) {\n      lines.push(\"\");\n    }\n\n    // format 사용 시 createFormat 호출 추가\n    if (usesFormat) {\n      lines.push(`const format = createFormat(\"${locale}\");`);\n      lines.push(\"\");\n    }\n\n    lines.push(\"/**\");\n    lines.push(` * Project ${locale.toUpperCase()} Dictionary`);\n    lines.push(\" */\");\n\n    if (isDefaultLocale) {\n      lines.push(\"export default {\");\n    } else {\n      lines.push(\"export default defineLocale({\");\n    }\n\n    for (const entry of sorted) {\n      if (entry.isFunction) {\n        // 함수인 경우: 원형 그대로 출력\n        lines.push(`  \"${entry.key}\": ${entry.value},`);\n      } else {\n        lines.push(`  \"${entry.key}\": ${JSON.stringify(entry.value)},`);\n      }\n    }\n\n    if (isDefaultLocale) {\n      lines.push(\"} as const;\");\n    } else {\n      lines.push(\"});\");\n    }\n    lines.push(\"\");\n\n    return lines.join(\"\\n\");\n  }\n\n  /**\n   * i18n 설정을 가져옵니다.\n   */\n  private getI18nConfig(): I18nConfig {\n    return Sonamu.config.i18n;\n  }\n\n  /**\n   * i18n 디렉토리 경로를 반환하고, 없으면 생성합니다.\n   */\n  private ensureI18nDir(): string {\n    const i18nDir = path.join(Sonamu.apiRootPath, \"src\", \"i18n\");\n    if (!fs.existsSync(i18nDir)) {\n      fs.mkdirSync(i18nDir, { recursive: true });\n    }\n    return i18nDir;\n  }\n\n  /**\n   * dict 파일을 저장합니다.\n   */\n  private saveDictFile(locale: string, entries: DictEntry[], isDefaultLocale: boolean): void {\n    const i18nDir = this.ensureI18nDir();\n    const dictPath = path.join(i18nDir, `${locale}.ts`);\n    const content = this.generateProjectDict(locale, entries, isDefaultLocale);\n    const formatted = formatCode(content, \"typescript\", dictPath);\n    fs.writeFileSync(dictPath, formatted, \"utf-8\");\n  }\n\n  /**\n   * i18n key를 파싱하여 entity 관련 정보 추출\n   */\n  parseEntityKey(key: string): EntityKeyInfo {\n    // entity.{EntityId} (list, create, edit 제외)\n    const entityTitleMatch = key.match(/^entity\\.([A-Z][a-zA-Z0-9]*)$/);\n    if (\n      entityTitleMatch &&\n      !key.includes(\".list\") &&\n      !key.includes(\".create\") &&\n      !key.includes(\".edit\")\n    ) {\n      return { type: \"entityTitle\", entityId: entityTitleMatch[1] };\n    }\n\n    // entity.{EntityId}.{propName}\n    const propDescMatch = key.match(/^entity\\.([A-Z][a-zA-Z0-9]*)\\.([a-z_][a-z0-9_]*)$/);\n    if (propDescMatch) {\n      return { type: \"propDesc\", entityId: propDescMatch[1], propName: propDescMatch[2] };\n    }\n\n    // enum.{EnumId}.{value}\n    const enumLabelMatch = key.match(/^enum\\.([A-Z][a-zA-Z0-9]*)\\.(.+)$/);\n    if (enumLabelMatch) {\n      return { type: \"enumLabel\", enumId: enumLabelMatch[1], enumValue: enumLabelMatch[2] };\n    }\n\n    return { type: \"other\" };\n  }\n\n  /**\n   * entity key에 대해 entity.json 업데이트 수행\n   * @returns 업데이트 여부\n   */\n  async updateEntityByKey(key: string, value: string): Promise<boolean> {\n    const keyInfo = this.parseEntityKey(key);\n\n    switch (keyInfo.type) {\n      case \"entityTitle\": {\n        try {\n          const entity = EntityManager.get(keyInfo.entityId);\n          if (entity.title !== value) {\n            entity.title = value;\n            await entity.save();\n            return true;\n          }\n        } catch {\n          // entity not found\n        }\n        return false;\n      }\n\n      case \"propDesc\": {\n        try {\n          const entity = EntityManager.get(keyInfo.entityId);\n          const propIndex = entity.props.findIndex((p) => p.name === keyInfo.propName);\n          if (propIndex !== -1 && entity.props[propIndex].desc !== value) {\n            entity.props[propIndex].desc = value;\n            await entity.save();\n            return true;\n          }\n        } catch {\n          // entity not found\n        }\n        return false;\n      }\n\n      case \"enumLabel\": {\n        for (const entityId of EntityManager.getAllIds()) {\n          const entity = EntityManager.get(entityId);\n          if (entity.enumLabels[keyInfo.enumId]) {\n            if (entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] !== value) {\n              entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] = value;\n              await entity.save();\n              return true;\n            }\n            break;\n          }\n        }\n        return false;\n      }\n\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * sd.generated.ts에서 entity labels 추출\n   * entity.json에서 관리되는 값만 포함 (.list, .create, .edit 제외)\n   */\n  extractEntityLabels(): DictEntry[] {\n    const sdPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", \"sd.generated.ts\");\n    if (!fs.existsSync(sdPath)) {\n      return [];\n    }\n\n    return this.parseConstObjectDeclaration(sdPath, \"entityLabels\");\n  }\n\n  /**\n   * sd.generated.ts에서 rc-keys 추출\n   * react-components에서 관리되는 i18n 키들\n   * @param locale - 로케일 (ko, en 등)\n   */\n  extractRCKeys(locale: string): DictEntry[] {\n    const sdPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", \"sd.generated.ts\");\n    if (!fs.existsSync(sdPath)) {\n      return [];\n    }\n\n    // locale별 변수명 매핑 (sd.template.ts의 getRCKeysVarName과 동일)\n    const varName = (() => {\n      if (locale === \"ko\") return \"rcKeysKo\";\n      if (locale === \"en\") return \"rcKeysEn\";\n      // 다른 locale은 en을 fallback으로 사용\n      return \"rcKeysEn\";\n    })();\n\n    return this.parseConstObjectDeclaration(sdPath, varName);\n  }\n\n  /**\n   * Project dict 파일([locale].ts)에서 딕셔너리 로드\n   */\n  loadProjectDict(locale: string): { entries: DictEntry[] } {\n    const dictPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", `${locale}.ts`);\n    if (!fs.existsSync(dictPath)) {\n      return { entries: [] };\n    }\n    return { entries: this.parseDictFile(dictPath) };\n  }\n\n  /**\n   * 딕셔너리 데이터 수집 (sonamu + entity + project)\n   */\n  async collectDictionary(): Promise<DictionaryResult> {\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    const rows: DictionaryRow[] = [];\n    const rowMap = new Map<string, DictionaryRow>();\n\n    // 1. RC Keys (sonamu source, 각 locale별)\n    for (const locale of locales) {\n      const rcKeys = this.extractRCKeys(locale);\n      for (const rcKey of rcKeys) {\n        let row = rowMap.get(rcKey.key);\n        if (!row) {\n          row = {\n            key: rcKey.key,\n            source: \"sonamu\",\n            isFunction: rcKey.isFunction ?? false,\n          };\n          rowMap.set(rcKey.key, row);\n        }\n        row[locale] = rcKey.value;\n        if (rcKey.isFunction) {\n          row.isFunction = true;\n        }\n      }\n    }\n\n    // 2. Entity labels (default locale 기준)\n    const entityLabels = this.extractEntityLabels();\n    for (const label of entityLabels) {\n      const row: DictionaryRow = {\n        key: label.key,\n        source: \"entity\",\n        isFunction: label.isFunction ?? false,\n        [defaultLocale]: label.value,\n      };\n      rowMap.set(label.key, row);\n    }\n\n    // 3. Project dict (각 locale별)\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      for (const entry of entries) {\n        const existing = rowMap.get(entry.key);\n        if (existing) {\n          // sonamu, entity source가 있으면 해당 locale 값만 추가\n          existing[locale] = entry.value;\n          if (entry.isFunction) {\n            existing.isFunction = true;\n          }\n        } else {\n          // project source로 새로 추가\n          let row = rowMap.get(entry.key);\n          if (!row) {\n            row = {\n              key: entry.key,\n              source: \"project\",\n              isFunction: entry.isFunction,\n            };\n            rowMap.set(entry.key, row);\n          }\n          row[locale] = entry.value;\n        }\n      }\n    }\n\n    rows.push(...rowMap.values());\n    rows.sort((a, b) => a.key.localeCompare(b.key));\n\n    // 통계 계산: locale별 (채워진 값 / 전체 키 수)\n    const stats: Record<string, { total: number; filled: number; percent: number }> = {};\n    const total = rows.length;\n    for (const locale of locales) {\n      const filled = rows.filter((row) => row[locale] != null && row[locale] !== \"\").length;\n      const percent = total > 0 ? Math.round((filled / total) * 100) : 0;\n      stats[locale] = { total, filled, percent };\n    }\n\n    return { rows, locales, defaultLocale, stats };\n  }\n\n  /**\n   * 딕셔너리 조회\n   */\n  async getDictionary(): Promise<DictionaryResult> {\n    return this.collectDictionary();\n  }\n\n  /**\n   * Excel로 내보내기\n   */\n  async exportToExcel(): Promise<{ filename: string; buffer: Buffer }> {\n    const { rows, locales } = await this.collectDictionary();\n\n    const wb = new Workbook();\n    const sheet = \"i18n\";\n    wb.setSheetName(\"Sheet1\", sheet);\n\n    const projectName = `${Sonamu.config.projectName ?? \"Sonamu\"} Dictionary`;\n    const headers = [\"key\", \"source\", ...locales];\n\n    // 스타일 정의\n    const titleStyleId = wb.addStyle({\n      font: { size: 23 },\n      alignment: { vertical: \"center\", horizontal: \"left\" },\n    });\n    const headerStyleId = wb.addStyle({\n      font: { bold: true, size: 11 },\n      alignment: { horizontal: \"center\", vertical: \"center\" },\n      fill: { pattern: \"solid\", fgColor: \"F1F1F1\" },\n      border: {\n        top: { style: \"thin\", color: \"D0D0D0\" },\n        left: { style: \"thin\", color: \"D0D0D0\" },\n        bottom: { style: \"thin\", color: \"D0D0D0\" },\n        right: { style: \"thin\", color: \"D0D0D0\" },\n      },\n    });\n    const dataStyleId = wb.addStyle({\n      font: { size: 11 },\n      alignment: { vertical: \"center\", horizontal: \"left\" },\n    });\n\n    // 행 1: 프로젝트명\n    wb.setCellValue(sheet, \"A1\", projectName);\n    wb.setCellStyle(sheet, \"A1\", titleStyleId);\n    wb.setRowHeight(sheet, 1, 28);\n\n    // 행 2: 빈 행 (기본값)\n\n    // 행 3: 헤더\n    wb.setRowValues(sheet, 3, \"A\", headers);\n    wb.setRowHeight(sheet, 3, 26);\n    for (let col = 0; col < headers.length; col++) {\n      wb.setCellStyle(sheet, `${colLetter(col)}3`, headerStyleId);\n    }\n\n    // 행 4 이후: 데이터\n    for (let i = 0; i < rows.length; i++) {\n      const row = rows[i];\n      const values = [row.key, row.source, ...locales.map((locale) => row[locale] ?? \"\")];\n      const rowNum = i + 4;\n      wb.setRowValues(sheet, rowNum, \"A\", values);\n      wb.setRowHeight(sheet, rowNum, 24);\n      for (let col = 0; col < values.length; col++) {\n        wb.setCellStyle(sheet, `${colLetter(col)}${rowNum}`, dataStyleId);\n      }\n    }\n\n    // 컬럼 너비 계산\n    const MAX_WIDTH = 50;\n    const MIN_WIDTH = 10;\n    const columnWidths: number[] = headers.map((header) => Math.max(header.length, MIN_WIDTH));\n\n    for (const row of rows) {\n      const values = [row.key, row.source, ...locales.map((locale) => row[locale] ?? \"\")];\n      values.forEach((value, idx) => {\n        const textLength = String(value).length;\n        columnWidths[idx] = Math.min(Math.max(columnWidths[idx], textLength), MAX_WIDTH);\n      });\n    }\n\n    // 컬럼 너비 적용\n    for (let col = 0; col < columnWidths.length; col++) {\n      wb.setColWidth(sheet, colLetter(col), columnWidths[col] + 2);\n    }\n\n    return {\n      filename: `${projectName}-${new Date().toISOString().split(\"T\")[0]}.xlsx`,\n      buffer: wb.writeBufferSync(),\n    };\n  }\n\n  /**\n   * Excel에서 가져오기\n   *\n   * 형식:\n   * - 1행: 프로젝트명\n   * - 2행: 빈 행\n   * - 3행: 헤더 (key, source, locales...)\n   * - 4행 이후: 데이터\n   */\n  async importFromExcel(buffer: Buffer): Promise<ImportResult> {\n    const wb = Workbook.openBufferSync(buffer);\n    const sheet = wb.sheetNames[0];\n    const allRows = wb.getRows(sheet);\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    let updatedEntities = 0;\n    let updatedLocales = 0;\n\n    // locale별 project dict entries\n    const projectDictEntries: Record<string, DictEntry[]> = {};\n    for (const locale of locales) {\n      projectDictEntries[locale] = [];\n    }\n\n    // 헤더 행 찾기: 첫 번째 컬럼(A)이 \"key\"인 행\n    let headerRowNum = 0;\n    for (const rowData of allRows) {\n      const firstCell = rowData.cells.find((c) => c.column === \"A\");\n      const firstCellValue = String(firstCell?.value ?? \"\")\n        .trim()\n        .toLowerCase();\n      if (firstCellValue === \"key\") {\n        headerRowNum = rowData.row;\n        break;\n      }\n    }\n\n    if (headerRowNum === 0) {\n      throw new BadRequestException(SD(\"sonamu.error.headerRowNotFound\"));\n    }\n\n    // 헤더 행에서 컬럼 매핑 구성\n    const headerRowData = allRows.find((r) => r.row === headerRowNum);\n    const colToHeader: Map<string, string> = new Map();\n    if (headerRowData) {\n      for (const cell of headerRowData.cells) {\n        colToHeader.set(cell.column, String(cell.value ?? \"\"));\n      }\n    }\n\n    // 데이터 행 읽기 (헤더 다음 행부터)\n    for (const rowData of allRows) {\n      if (rowData.row <= headerRowNum) continue;\n\n      const rowValues: Record<string, string> = {};\n      for (const cell of rowData.cells) {\n        const headerName = colToHeader.get(cell.column);\n        if (headerName) {\n          rowValues[headerName] = String(cell.value ?? \"\");\n        }\n      }\n\n      const key = rowValues.key;\n      const source = rowValues.source as \"entity\" | \"project\";\n\n      if (!key || !source) continue;\n\n      if (source === \"entity\") {\n        // entity source: default locale만 entity.json에 저장\n        const defaultValue = rowValues[defaultLocale];\n        if (defaultValue) {\n          const updated = await this.updateEntityByKey(key, defaultValue);\n          if (updated) {\n            updatedEntities++;\n          }\n        }\n\n        // non-default locale은 project dict에 저장\n        for (const locale of locales) {\n          if (locale === defaultLocale) continue;\n          const cellValue = rowValues[locale]?.trim();\n          if (cellValue) {\n            projectDictEntries[locale].push({\n              key,\n              value: cellValue,\n              isFunction: this.isExpressionFunction(cellValue),\n            });\n          }\n        }\n      } else if (source === \"project\") {\n        // project source: 모든 locale을 project dict에 저장\n        for (const locale of locales) {\n          const cellValue = rowValues[locale]?.trim();\n          if (cellValue) {\n            projectDictEntries[locale].push({\n              key,\n              value: cellValue,\n              isFunction: this.isExpressionFunction(cellValue),\n            });\n          }\n        }\n      }\n    }\n\n    // Project dict 파일 생성\n    for (const locale of locales) {\n      const entries = projectDictEntries[locale];\n      if (entries.length > 0) {\n        this.saveDictFile(locale, entries, locale === defaultLocale);\n        updatedLocales++;\n      }\n    }\n\n    return {\n      success: true,\n      updatedEntities,\n      updatedLocales,\n    };\n  }\n\n  /**\n   * 딕셔너리 항목 수정\n   */\n  async updateEntry(params: {\n    oldKey: string;\n    newKey: string;\n    source: \"entity\" | \"project\" | \"sonamu\";\n    values: Record<string, string>;\n  }): Promise<void> {\n    const { oldKey, newKey, source, values } = params;\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    // entity source의 default locale 처리\n    if (source === \"entity\" && values[defaultLocale]) {\n      await this.updateEntityByKey(newKey, values[defaultLocale]);\n    }\n\n    // project dict 업데이트\n    // - entity의 non-default locale\n    // - project source의 모든 locale\n    // - sonamu source의 모든 locale (override)\n    for (const locale of locales) {\n      // entity source의 default locale은 entity.json에서 처리했으므로 스킵\n      if (source === \"entity\" && locale === defaultLocale) continue;\n\n      const cellValue = values[locale]?.trim();\n      if (!cellValue) continue;\n\n      // 기존 dict 로드\n      const { entries } = this.loadProjectDict(locale);\n\n      // key 변경 시 기존 key 제거\n      if (oldKey !== newKey) {\n        const oldIndex = entries.findIndex((e) => e.key === oldKey);\n        if (oldIndex !== -1) {\n          entries.splice(oldIndex, 1);\n        }\n      }\n\n      // 새 값 업데이트 또는 추가\n      const existingIndex = entries.findIndex((e) => e.key === newKey);\n      const newEntry: DictEntry = {\n        key: newKey,\n        value: cellValue,\n        isFunction: this.isExpressionFunction(cellValue),\n      };\n\n      if (existingIndex !== -1) {\n        entries[existingIndex] = newEntry;\n      } else {\n        entries.push(newEntry);\n      }\n\n      // dict 파일 저장\n      this.saveDictFile(locale, entries, locale === defaultLocale);\n    }\n  }\n\n  /**\n   * 딕셔너리 항목 추가\n   */\n  async createEntry(params: { key: string; values: Record<string, string> }): Promise<void> {\n    const { key, values } = params;\n\n    if (!key?.trim()) {\n      throw new BadRequestException(SD(\"sonamu.error.keyRequired\"));\n    }\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    // 중복 키 체크\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      if (entries.some((e) => e.key === key)) {\n        throw new BadRequestException(SD(\"sonamu.error.keyAlreadyExists\")(key));\n      }\n    }\n\n    // 각 locale에 새 키 추가\n    for (const locale of locales) {\n      const cellValue = values[locale]?.trim();\n      if (!cellValue) continue;\n\n      const { entries } = this.loadProjectDict(locale);\n      entries.push({\n        key,\n        value: cellValue,\n        isFunction: this.isExpressionFunction(cellValue),\n      });\n\n      this.saveDictFile(locale, entries, locale === defaultLocale);\n    }\n  }\n\n  /**\n   * 딕셔너리 항목 삭제\n   */\n  async deleteEntry(key: string): Promise<void> {\n    if (!key) {\n      throw new BadRequestException(SD(\"sonamu.error.keyRequired\"));\n    }\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    let deleted = false;\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      const index = entries.findIndex((e) => e.key === key);\n      if (index !== -1) {\n        entries.splice(index, 1);\n        deleted = true;\n\n        this.saveDictFile(locale, entries, locale === defaultLocale);\n      }\n    }\n\n    if (!deleted) {\n      throw new BadRequestException(SD(\"sonamu.error.keyNotFound\")(key));\n    }\n  }\n\n  /**\n   * 미사용 키 검사 (ast-grep 사용)\n   */\n  async checkUsage(keys: string[]): Promise<UsageResult> {\n    // ast-grep 설치 확인\n    let sgPath: string | null = null;\n    try {\n      sgPath = execSync(\"which sg\", { encoding: \"utf-8\" }).trim();\n    } catch {\n      try {\n        sgPath = execSync(\"which ast-grep\", { encoding: \"utf-8\" }).trim();\n      } catch {\n        // ast-grep not installed\n      }\n    }\n\n    if (!sgPath) {\n      return {\n        error:\n          \"ast-grep이 설치되어 있지 않습니다. brew install ast-grep 또는 npm install -g @ast-grep/cli로 설치해주세요.\",\n        unusedKeys: [],\n      };\n    }\n\n    const searchPaths: string[] = [];\n    for (const entry of [\"api\", \"web\", \"app\"]) {\n      const srcPath = path.join(Sonamu.appRootPath, entry, \"src\");\n      if (fs.existsSync(srcPath)) {\n        searchPaths.push(srcPath);\n      }\n    }\n\n    if (searchPaths.length === 0) {\n      return {\n        error: \"검색할 src 디렉토리를 찾을 수 없습니다.\",\n        unusedKeys: [],\n      };\n    }\n\n    const usedKeys = new Set<string>();\n\n    try {\n      // ast-grep으로 SD(\"...\") 패턴 검색\n      // 패턴: SD(\"KEY\") 또는 SD('KEY') 형태\n      const patterns = ['SD(\"$KEY\")', \"SD('$KEY')\"];\n\n      for (const searchPath of searchPaths) {\n        for (const pattern of patterns) {\n          try {\n            const result = execSync(`${sgPath} --pattern '${pattern}' --json ${searchPath}`, {\n              encoding: \"utf-8\",\n              maxBuffer: 50 * 1024 * 1024, // 50MB\n            });\n\n            if (result.trim()) {\n              const matches = JSON.parse(result);\n              for (const match of matches) {\n                // metaVariables.single.KEY.text에서 키 추출\n                const keyText = match.metaVariables?.single?.KEY?.text;\n                if (keyText) {\n                  // 따옴표 제거\n                  const cleanKey = keyText.replace(/^[\"']|[\"']$/g, \"\");\n                  usedKeys.add(cleanKey);\n                }\n              }\n            }\n          } catch {\n            // 패턴 매치 없으면 에러 (무시)\n          }\n        }\n      }\n\n      // keys 중에서 usedKeys에 없는 것들이 미사용 키\n      const unusedKeys = keys.filter((k) => !usedKeys.has(k));\n\n      return { unusedKeys, usedKeysCount: usedKeys.size };\n    } catch (e) {\n      return {\n        error: `검색 중 오류 발생: ${e instanceof Error ? e.message : String(e)}`,\n        unusedKeys: [],\n      };\n    }\n  }\n}\n\nexport const sonamuDictionary = new SonamuDictionary();\n"],"names":["Workbook","execSync","fs","path","ts","Sonamu","EntityManager","BadRequestException","formatCode","SD","colLetter","index","result","n","String","fromCharCode","Math","floor","SonamuDictionary","parseDictFile","filePath","content","readFileSync","sourceFile","createSourceFile","ScriptTarget","Latest","entries","forEachChild","node","isExportAssignment","objectLiteral","unwrapToObjectLiteral","expression","extractEntriesFromObject","parseConstObjectDeclaration","varName","isVariableStatement","decl","declarationList","declarations","isIdentifier","name","text","initializer","isExpressionFunction","code","trim","ARROW_FUNCTION_PATTERN","test","expr","isAsExpression","isObjectLiteralExpression","isCallExpression","firstArg","arguments","prop","properties","entry","extractDictEntry","push","getPropertyKey","isStringLiteral","isPropertyAssignment","key","init","isArrowFunction","funcText","getText","normalized","replace","value","isFunction","isNoSubstitutionTemplateLiteral","isFunctionExpression","getProjectDictPath","locale","target","dir","config","api","join","appRootPath","getSonamuDictPath","packageRoot","resolve","dirname","ensureDictKeys","requiredKeys","defaultLocale","i18n","projectDictPath","existsSync","projectEntries","existingKeys","Set","map","e","missingKeys","filter","has","length","sonamuDictPath","sonamuEntries","sonamuDict","Map","entriesToAdd","get","undefined","appendEntriesToDictFile","isDefaultLocale","existingEntries","generateProjectDict","formatted","writeFileSync","detectUsedHelpers","functionEntries","helpers","helper","pattern","RegExp","some","formatPattern","usesFormat","sorted","sort","a","b","localeCompare","lines","imports","toUpperCase","JSON","stringify","getI18nConfig","ensureI18nDir","i18nDir","apiRootPath","mkdirSync","recursive","saveDictFile","dictPath","parseEntityKey","entityTitleMatch","match","includes","type","entityId","propDescMatch","propName","enumLabelMatch","enumId","enumValue","updateEntityByKey","keyInfo","entity","title","save","propIndex","props","findIndex","p","desc","getAllIds","enumLabels","extractEntityLabels","sdPath","extractRCKeys","loadProjectDict","collectDictionary","supportedLocales","locales","rows","rowMap","rcKeys","rcKey","row","source","set","entityLabels","label","existing","values","stats","total","filled","percent","round","getDictionary","exportToExcel","wb","sheet","setSheetName","projectName","headers","titleStyleId","addStyle","font","size","alignment","vertical","horizontal","headerStyleId","bold","fill","fgColor","border","top","style","color","left","bottom","right","dataStyleId","setCellValue","setCellStyle","setRowHeight","setRowValues","col","i","rowNum","MAX_WIDTH","MIN_WIDTH","columnWidths","header","max","forEach","idx","textLength","min","setColWidth","filename","Date","toISOString","split","buffer","writeBufferSync","importFromExcel","openBufferSync","sheetNames","allRows","getRows","updatedEntities","updatedLocales","projectDictEntries","headerRowNum","rowData","firstCell","cells","find","c","column","firstCellValue","toLowerCase","headerRowData","r","colToHeader","cell","rowValues","headerName","defaultValue","updated","cellValue","success","updateEntry","params","oldKey","newKey","oldIndex","splice","existingIndex","newEntry","createEntry","deleteEntry","deleted","checkUsage","keys","sgPath","encoding","error","unusedKeys","searchPaths","srcPath","usedKeys","patterns","searchPath","maxBuffer","matches","parse","keyText","metaVariables","single","KEY","cleanKey","add","k","usedKeysCount","Error","message","sonamuDictionary"],"mappings":"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"}
+//#endregion
+init_sonamu_dictionary();
+export { SonamuDictionary, init_sonamu_dictionary, sonamuDictionary };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu-dictionary.js","names":["entries: DictEntry[]","helpers: string[]","lines: string[]","rows: DictionaryRow[]","row: DictionaryRow","stats: Record<string, { total: number; filled: number; percent: number }>","columnWidths: number[]","projectDictEntries: Record<string, DictEntry[]>","colToHeader: Map<string, string>","rowValues: Record<string, string>","newEntry: DictEntry","sgPath: string | null","searchPaths: string[]"],"sources":["../../src/dict/sonamu-dictionary.ts"],"sourcesContent":["import { execSync } from \"child_process\";\nimport fs from \"fs\";\nimport path from \"path\";\n\nimport { Workbook } from \"@sheetkit/node\";\nimport ts from \"typescript\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { BadRequestException } from \"../exceptions/so-exceptions\";\nimport { formatCode } from \"../utils/formatter\";\nimport { SD } from \"./sd\";\nimport {\n  type DictEntry,\n  type DictionaryResult,\n  type DictionaryRow,\n  type EntityKeyInfo,\n  type I18nConfig,\n  type ImportResult,\n  type UsageResult,\n} from \"./types\";\n\n/**\n * 0-based 컬럼 인덱스를 엑셀 컬럼 문자로 변환 (0 -> \"A\", 25 -> \"Z\", 26 -> \"AA\")\n */\nfunction colLetter(index: number): string {\n  let result = \"\";\n  let n = index;\n  while (n >= 0) {\n    result = String.fromCharCode(65 + (n % 26)) + result;\n    n = Math.floor(n / 26) - 1;\n  }\n  return result;\n}\n\n/**\n * Sonamu Dictionary 관리 클래스\n * i18n 딕셔너리의 CRUD 및 Excel import/export를 담당합니다.\n */\nexport class SonamuDictionary {\n  /**\n   * TypeScript Compiler API를 사용하여 dict 파일 파싱\n   *\n   * 지원 패턴:\n   * - export default { ... } as const;\n   * - export default defineLocale({ ... });\n   * - 문자열 값: \"key\": \"value\" 또는 key: `value`\n   * - 함수 값: \"key\": (param: Type) => `template`\n   */\n  parseDictFile(filePath: string): DictEntry[] {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);\n\n    const entries: DictEntry[] = [];\n\n    ts.forEachChild(sourceFile, (node) => {\n      if (ts.isExportAssignment(node)) {\n        const objectLiteral = this.unwrapToObjectLiteral(node.expression);\n        if (objectLiteral) {\n          this.extractEntriesFromObject(objectLiteral, sourceFile, entries);\n        }\n      }\n    });\n\n    return entries;\n  }\n\n  /**\n   * 파일에서 특정 이름의 const 선언을 찾아 ObjectLiteral 파싱\n   * 예: const entityLabels = { ... } as const;\n   */\n  parseConstObjectDeclaration(filePath: string, varName: string): DictEntry[] {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);\n\n    const entries: DictEntry[] = [];\n\n    ts.forEachChild(sourceFile, (node) => {\n      if (ts.isVariableStatement(node)) {\n        for (const decl of node.declarationList.declarations) {\n          if (ts.isIdentifier(decl.name) && decl.name.text === varName && decl.initializer) {\n            const objectLiteral = this.unwrapToObjectLiteral(decl.initializer);\n            if (objectLiteral) {\n              this.extractEntriesFromObject(objectLiteral, sourceFile, entries);\n            }\n          }\n        }\n      }\n    });\n\n    return entries;\n  }\n\n  /**\n   * 문자열이 화살표 함수 또는 함수 표현식인지 판별\n   */\n  isExpressionFunction(code: string): boolean {\n    // 빈 문자열이나 공백만 있는 경우\n    if (!code.trim()) {\n      return false;\n    }\n\n    const ARROW_FUNCTION_PATTERN = /^\\s*\\([^)]*\\)\\s*=>/;\n\n    return ARROW_FUNCTION_PATTERN.test(code);\n  }\n\n  /**\n   * export default 표현식에서 ObjectLiteralExpression 추출\n   * - as const 처리\n   * - defineLocale({ ... }) 호출 처리\n   */\n  private unwrapToObjectLiteral(expr: ts.Expression): ts.ObjectLiteralExpression | null {\n    // as const 처리\n    if (ts.isAsExpression(expr)) {\n      return this.unwrapToObjectLiteral(expr.expression);\n    }\n    // 직접 객체 리터럴\n    if (ts.isObjectLiteralExpression(expr)) {\n      return expr;\n    }\n    // defineLocale({ ... }) 호출\n    if (ts.isCallExpression(expr)) {\n      const firstArg = expr.arguments[0];\n      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {\n        return firstArg;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * ObjectLiteralExpression에서 DictEntry 추출\n   */\n  private extractEntriesFromObject(\n    objectLiteral: ts.ObjectLiteralExpression,\n    sourceFile: ts.SourceFile,\n    entries: DictEntry[],\n  ): void {\n    for (const prop of objectLiteral.properties) {\n      const entry = this.extractDictEntry(prop, sourceFile);\n      if (entry) {\n        entries.push(entry);\n      }\n    }\n  }\n\n  /**\n   * PropertyName에서 키 문자열 추출\n   * - 문자열 리터럴: \"key\"\n   * - 식별자: key (unquoted)\n   */\n  private getPropertyKey(name: ts.PropertyName): string | null {\n    if (ts.isStringLiteral(name)) {\n      return name.text;\n    }\n    if (ts.isIdentifier(name)) {\n      return name.text;\n    }\n    return null;\n  }\n\n  /**\n   * 프로퍼티에서 DictEntry 추출\n   * - 문자열: 실제 문자열 값\n   * - 함수: 원본 소스 (여러 줄은 한 줄로 정규화)\n   */\n  private extractDictEntry(\n    prop: ts.ObjectLiteralElementLike,\n    sourceFile: ts.SourceFile,\n  ): DictEntry | null {\n    if (!ts.isPropertyAssignment(prop)) {\n      return null;\n    }\n\n    const key = this.getPropertyKey(prop.name);\n    if (!key) return null;\n\n    const init = prop.initializer;\n\n    // 화살표 함수\n    if (ts.isArrowFunction(init)) {\n      const funcText = init.getText(sourceFile);\n      const normalized = funcText.replace(/\\s*\\n\\s*/g, \" \").trim();\n      return { key, value: normalized, isFunction: true };\n    }\n\n    // 문자열 리터럴\n    if (ts.isStringLiteral(init)) {\n      return { key, value: init.text, isFunction: false };\n    }\n\n    // 템플릿 리터럴 (변수 없음)\n    if (ts.isNoSubstitutionTemplateLiteral(init)) {\n      return { key, value: init.text, isFunction: false };\n    }\n\n    // 기타 (예: 함수 표현식)\n    return {\n      key,\n      value: init.getText(sourceFile),\n      isFunction: ts.isFunctionExpression(init),\n    };\n  }\n\n  /**\n   * 프로젝트의 i18n dict 파일 경로를 반환합니다.\n   * @param locale - 로케일 (ko, en 등)\n   * @param target - 타겟 디렉토리 (api, web, app)\n   */\n  getProjectDictPath(locale: string, target: \"api\" | \"web\" | \"app\" = \"api\"): string {\n    const dir = target === \"api\" ? Sonamu.config.api.dir : target;\n    return path.join(Sonamu.appRootPath, dir, \"src\", \"i18n\", `${locale}.ts`);\n  }\n\n  /**\n   * sonamu 내장 dict 파일 경로를 반환합니다.\n   */\n  private getSonamuDictPath(locale: string): string {\n    const packageRoot = path.resolve(import.meta.dirname, \"..\", \"..\");\n    return path.join(packageRoot, \"src\", \"dict\", `${locale}.ts`);\n  }\n\n  /**\n   * 필요한 dict 키가 프로젝트에 존재하는지 확인하고, 없으면 추가합니다.\n   * defaultLocale에만 추가하며, 다른 locale은 사용자가 직접 번역해야 합니다.\n   *\n   * @param requiredKeys - 필요한 키 목록\n   * @param target - 타겟 디렉토리 (api, web, app)\n   * @returns 추가된 키 목록\n   */\n  async ensureDictKeys(\n    requiredKeys: string[],\n    target: \"api\" | \"web\" | \"app\" = \"api\",\n  ): Promise<string[]> {\n    const { defaultLocale } = Sonamu.config.i18n;\n    const projectDictPath = this.getProjectDictPath(defaultLocale, target);\n\n    // 프로젝트 dict 파일이 없으면 아무것도 하지 않음\n    if (!fs.existsSync(projectDictPath)) {\n      return [];\n    }\n\n    // 프로젝트 dict에서 기존 키 파싱\n    const projectEntries = this.parseDictFile(projectDictPath);\n    const existingKeys = new Set(projectEntries.map((e) => e.key));\n\n    // 누락된 키 찾기\n    const missingKeys = requiredKeys.filter((key) => !existingKeys.has(key));\n\n    if (missingKeys.length === 0) {\n      return [];\n    }\n\n    // sonamu dict에서 기본값 가져오기\n    const sonamuDictPath = this.getSonamuDictPath(defaultLocale);\n    if (!fs.existsSync(sonamuDictPath)) {\n      return [];\n    }\n\n    const sonamuEntries = this.parseDictFile(sonamuDictPath);\n    const sonamuDict = new Map(sonamuEntries.map((e) => [e.key, e]));\n\n    // 추가할 엔트리 생성\n    const entriesToAdd = missingKeys\n      .map((key) => sonamuDict.get(key))\n      .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);\n\n    if (entriesToAdd.length === 0) {\n      return [];\n    }\n\n    // 프로젝트 dict 파일에 추가\n    await this.appendEntriesToDictFile(projectDictPath, entriesToAdd, defaultLocale, true);\n\n    return entriesToAdd.map((e) => e.key);\n  }\n\n  /**\n   * dict 파일에 엔트리를 추가합니다.\n   * 기존 파일을 파싱하고, 새 엔트리를 추가한 뒤, 전체 파일을 재생성합니다.\n   */\n  private async appendEntriesToDictFile(\n    filePath: string,\n    entries: DictEntry[],\n    locale: string,\n    isDefaultLocale: boolean,\n  ): Promise<void> {\n    // 기존 entries 파싱\n    const existingEntries = this.parseDictFile(filePath);\n\n    // 새 entries 추가\n    for (const entry of entries) {\n      existingEntries.push(entry);\n    }\n\n    // 파일 재생성\n    const content = this.generateProjectDict(locale, existingEntries, isDefaultLocale);\n    const formatted = await formatCode(content, \"typescript\", filePath);\n    fs.writeFileSync(filePath, formatted, \"utf-8\");\n  }\n\n  /**\n   * 함수 값들에서 사용되는 헬퍼 함수를 감지합니다.\n   */\n  private detectUsedHelpers(entries: DictEntry[]): {\n    helpers: string[];\n    usesFormat: boolean;\n  } {\n    const functionEntries = entries.filter((e) => e.isFunction);\n    const helpers: string[] = [];\n\n    for (const helper of [\"plural\", \"josa\"]) {\n      // 함수명이 단어 경계로 사용되는지 확인 (예: plural( 또는 plural,)\n      const pattern = new RegExp(`\\\\b${helper}\\\\s*\\\\(`);\n      if (functionEntries.some((e) => pattern.test(e.value))) {\n        helpers.push(helper);\n      }\n    }\n\n    // format 사용 여부 별도 감지 (format.number(...), format.date(...) 등)\n    const formatPattern = /\\bformat\\.\\w+\\s*\\(/;\n    const usesFormat = functionEntries.some((e) => formatPattern.test(e.value));\n\n    return { helpers, usesFormat };\n  }\n\n  /**\n   * Project dict 파일 생성\n   */\n  generateProjectDict(locale: string, entries: DictEntry[], isDefaultLocale: boolean): string {\n    // key 알파벳 순 정렬\n    const sorted = [...entries].toSorted((a, b) => a.key.localeCompare(b.key));\n\n    const lines: string[] = [];\n\n    // 함수 값에서 사용되는 헬퍼 함수 감지\n    const { helpers, usesFormat } = this.detectUsedHelpers(entries);\n\n    // 헬퍼 함수 import 추가\n    const imports = [...helpers];\n    if (usesFormat) {\n      imports.push(\"createFormat\");\n    }\n    if (imports.length > 0) {\n      lines.push(`import { ${imports.join(\", \")} } from \"sonamu/dict\";`);\n    }\n\n    if (!isDefaultLocale) {\n      lines.push('import { defineLocale } from \"./sd.generated\";');\n    }\n\n    if (imports.length > 0 || !isDefaultLocale) {\n      lines.push(\"\");\n    }\n\n    // format 사용 시 createFormat 호출 추가\n    if (usesFormat) {\n      lines.push(`const format = createFormat(\"${locale}\");`);\n      lines.push(\"\");\n    }\n\n    lines.push(\"/**\");\n    lines.push(` * Project ${locale.toUpperCase()} Dictionary`);\n    lines.push(\" */\");\n\n    if (isDefaultLocale) {\n      lines.push(\"export default {\");\n    } else {\n      lines.push(\"export default defineLocale({\");\n    }\n\n    for (const entry of sorted) {\n      if (entry.isFunction) {\n        // 함수인 경우: 원형 그대로 출력\n        lines.push(`  \"${entry.key}\": ${entry.value},`);\n      } else {\n        lines.push(`  \"${entry.key}\": ${JSON.stringify(entry.value)},`);\n      }\n    }\n\n    if (isDefaultLocale) {\n      lines.push(\"} as const;\");\n    } else {\n      lines.push(\"});\");\n    }\n    lines.push(\"\");\n\n    return lines.join(\"\\n\");\n  }\n\n  /**\n   * i18n 설정을 가져옵니다.\n   */\n  private getI18nConfig(): I18nConfig {\n    return Sonamu.config.i18n;\n  }\n\n  /**\n   * i18n 디렉토리 경로를 반환하고, 없으면 생성합니다.\n   */\n  private ensureI18nDir(): string {\n    const i18nDir = path.join(Sonamu.apiRootPath, \"src\", \"i18n\");\n    if (!fs.existsSync(i18nDir)) {\n      fs.mkdirSync(i18nDir, { recursive: true });\n    }\n    return i18nDir;\n  }\n\n  /**\n   * dict 파일을 저장합니다.\n   */\n  private async saveDictFile(\n    locale: string,\n    entries: DictEntry[],\n    isDefaultLocale: boolean,\n  ): Promise<void> {\n    const i18nDir = this.ensureI18nDir();\n    const dictPath = path.join(i18nDir, `${locale}.ts`);\n    const content = this.generateProjectDict(locale, entries, isDefaultLocale);\n    const formatted = await formatCode(content, \"typescript\", dictPath);\n    fs.writeFileSync(dictPath, formatted, \"utf-8\");\n  }\n\n  /**\n   * i18n key를 파싱하여 entity 관련 정보 추출\n   */\n  parseEntityKey(key: string): EntityKeyInfo {\n    // entity.{EntityId} (list, create, edit 제외)\n    const entityTitleMatch = key.match(/^entity\\.([A-Z][a-zA-Z0-9]*)$/);\n    if (\n      entityTitleMatch &&\n      !key.includes(\".list\") &&\n      !key.includes(\".create\") &&\n      !key.includes(\".edit\")\n    ) {\n      return { type: \"entityTitle\", entityId: entityTitleMatch[1] };\n    }\n\n    // entity.{EntityId}.{propName}\n    const propDescMatch = key.match(/^entity\\.([A-Z][a-zA-Z0-9]*)\\.([a-z_][a-z0-9_]*)$/);\n    if (propDescMatch) {\n      return { type: \"propDesc\", entityId: propDescMatch[1], propName: propDescMatch[2] };\n    }\n\n    // enum.{EnumId}.{value}\n    const enumLabelMatch = key.match(/^enum\\.([A-Z][a-zA-Z0-9]*)\\.(.+)$/);\n    if (enumLabelMatch) {\n      return { type: \"enumLabel\", enumId: enumLabelMatch[1], enumValue: enumLabelMatch[2] };\n    }\n\n    return { type: \"other\" };\n  }\n\n  /**\n   * entity key에 대해 entity.json 업데이트 수행\n   * @returns 업데이트 여부\n   */\n  async updateEntityByKey(key: string, value: string): Promise<boolean> {\n    const keyInfo = this.parseEntityKey(key);\n\n    switch (keyInfo.type) {\n      case \"entityTitle\": {\n        try {\n          const entity = EntityManager.get(keyInfo.entityId);\n          if (entity.title !== value) {\n            entity.title = value;\n            await entity.save();\n            return true;\n          }\n        } catch {\n          // entity not found\n        }\n        return false;\n      }\n\n      case \"propDesc\": {\n        try {\n          const entity = EntityManager.get(keyInfo.entityId);\n          const propIndex = entity.props.findIndex((p) => p.name === keyInfo.propName);\n          if (propIndex !== -1 && entity.props[propIndex].desc !== value) {\n            entity.props[propIndex].desc = value;\n            await entity.save();\n            return true;\n          }\n        } catch {\n          // entity not found\n        }\n        return false;\n      }\n\n      case \"enumLabel\": {\n        for (const entityId of EntityManager.getAllIds()) {\n          const entity = EntityManager.get(entityId);\n          if (entity.enumLabels[keyInfo.enumId]) {\n            if (entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] !== value) {\n              entity.enumLabels[keyInfo.enumId][keyInfo.enumValue] = value;\n              await entity.save();\n              return true;\n            }\n            break;\n          }\n        }\n        return false;\n      }\n\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * sd.generated.ts에서 entity labels 추출\n   * entity.json에서 관리되는 값만 포함 (.list, .create, .edit 제외)\n   */\n  extractEntityLabels(): DictEntry[] {\n    const sdPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", \"sd.generated.ts\");\n    if (!fs.existsSync(sdPath)) {\n      return [];\n    }\n\n    return this.parseConstObjectDeclaration(sdPath, \"entityLabels\");\n  }\n\n  /**\n   * sd.generated.ts에서 rc-keys 추출\n   * react-components에서 관리되는 i18n 키들\n   * @param locale - 로케일 (ko, en 등)\n   */\n  extractRCKeys(locale: string): DictEntry[] {\n    const sdPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", \"sd.generated.ts\");\n    if (!fs.existsSync(sdPath)) {\n      return [];\n    }\n\n    // locale별 변수명 매핑 (sd.template.ts의 getRCKeysVarName과 동일)\n    const varName = (() => {\n      if (locale === \"ko\") return \"rcKeysKo\";\n      if (locale === \"en\") return \"rcKeysEn\";\n      // 다른 locale은 en을 fallback으로 사용\n      return \"rcKeysEn\";\n    })();\n\n    return this.parseConstObjectDeclaration(sdPath, varName);\n  }\n\n  /**\n   * Project dict 파일([locale].ts)에서 딕셔너리 로드\n   */\n  loadProjectDict(locale: string): { entries: DictEntry[] } {\n    const dictPath = path.join(Sonamu.apiRootPath, \"src\", \"i18n\", `${locale}.ts`);\n    if (!fs.existsSync(dictPath)) {\n      return { entries: [] };\n    }\n    return { entries: this.parseDictFile(dictPath) };\n  }\n\n  /**\n   * 딕셔너리 데이터 수집 (sonamu + entity + project)\n   */\n  async collectDictionary(): Promise<DictionaryResult> {\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    const rows: DictionaryRow[] = [];\n    const rowMap = new Map<string, DictionaryRow>();\n\n    // 1. RC Keys (sonamu source, 각 locale별)\n    for (const locale of locales) {\n      const rcKeys = this.extractRCKeys(locale);\n      for (const rcKey of rcKeys) {\n        let row = rowMap.get(rcKey.key);\n        if (!row) {\n          row = {\n            key: rcKey.key,\n            source: \"sonamu\",\n            isFunction: rcKey.isFunction ?? false,\n          };\n          rowMap.set(rcKey.key, row);\n        }\n        row[locale] = rcKey.value;\n        if (rcKey.isFunction) {\n          row.isFunction = true;\n        }\n      }\n    }\n\n    // 2. Entity labels (default locale 기준)\n    const entityLabels = this.extractEntityLabels();\n    for (const label of entityLabels) {\n      const row: DictionaryRow = {\n        key: label.key,\n        source: \"entity\",\n        isFunction: label.isFunction ?? false,\n        [defaultLocale]: label.value,\n      };\n      rowMap.set(label.key, row);\n    }\n\n    // 3. Project dict (각 locale별)\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      for (const entry of entries) {\n        const existing = rowMap.get(entry.key);\n        if (existing) {\n          // sonamu, entity source가 있으면 해당 locale 값만 추가\n          existing[locale] = entry.value;\n          if (entry.isFunction) {\n            existing.isFunction = true;\n          }\n        } else {\n          // project source로 새로 추가\n          let row = rowMap.get(entry.key);\n          if (!row) {\n            row = {\n              key: entry.key,\n              source: \"project\",\n              isFunction: entry.isFunction,\n            };\n            rowMap.set(entry.key, row);\n          }\n          row[locale] = entry.value;\n        }\n      }\n    }\n\n    rows.push(...rowMap.values());\n    rows.sort((a, b) => a.key.localeCompare(b.key));\n\n    // 통계 계산: locale별 (채워진 값 / 전체 키 수)\n    const stats: Record<string, { total: number; filled: number; percent: number }> = {};\n    const total = rows.length;\n    for (const locale of locales) {\n      const filled = rows.filter((row) => row[locale] != null && row[locale] !== \"\").length;\n      const percent = total > 0 ? Math.round((filled / total) * 100) : 0;\n      stats[locale] = { total, filled, percent };\n    }\n\n    return { rows, locales, defaultLocale, stats };\n  }\n\n  /**\n   * 딕셔너리 조회\n   */\n  async getDictionary(): Promise<DictionaryResult> {\n    return this.collectDictionary();\n  }\n\n  /**\n   * Excel로 내보내기\n   */\n  async exportToExcel(): Promise<{ filename: string; buffer: Buffer }> {\n    const { rows, locales } = await this.collectDictionary();\n\n    const wb = new Workbook();\n    const sheet = \"i18n\";\n    wb.setSheetName(\"Sheet1\", sheet);\n\n    const projectName = `${Sonamu.config.projectName ?? \"Sonamu\"} Dictionary`;\n    const headers = [\"key\", \"source\", ...locales];\n\n    // 스타일 정의\n    const titleStyleId = wb.addStyle({\n      font: { size: 23 },\n      alignment: { vertical: \"center\", horizontal: \"left\" },\n    });\n    const headerStyleId = wb.addStyle({\n      font: { bold: true, size: 11 },\n      alignment: { horizontal: \"center\", vertical: \"center\" },\n      fill: { pattern: \"solid\", fgColor: \"F1F1F1\" },\n      border: {\n        top: { style: \"thin\", color: \"D0D0D0\" },\n        left: { style: \"thin\", color: \"D0D0D0\" },\n        bottom: { style: \"thin\", color: \"D0D0D0\" },\n        right: { style: \"thin\", color: \"D0D0D0\" },\n      },\n    });\n    const dataStyleId = wb.addStyle({\n      font: { size: 11 },\n      alignment: { vertical: \"center\", horizontal: \"left\" },\n    });\n\n    // 행 1: 프로젝트명\n    wb.setCellValue(sheet, \"A1\", projectName);\n    wb.setCellStyle(sheet, \"A1\", titleStyleId);\n    wb.setRowHeight(sheet, 1, 28);\n\n    // 행 2: 빈 행 (기본값)\n\n    // 행 3: 헤더\n    wb.setRowValues(sheet, 3, \"A\", headers);\n    wb.setRowHeight(sheet, 3, 26);\n    for (let col = 0; col < headers.length; col++) {\n      wb.setCellStyle(sheet, `${colLetter(col)}3`, headerStyleId);\n    }\n\n    // 행 4 이후: 데이터\n    for (let i = 0; i < rows.length; i++) {\n      const row = rows[i];\n      const values = [row.key, row.source, ...locales.map((locale) => row[locale] ?? \"\")];\n      const rowNum = i + 4;\n      wb.setRowValues(sheet, rowNum, \"A\", values);\n      wb.setRowHeight(sheet, rowNum, 24);\n      for (let col = 0; col < values.length; col++) {\n        wb.setCellStyle(sheet, `${colLetter(col)}${rowNum}`, dataStyleId);\n      }\n    }\n\n    // 컬럼 너비 계산\n    const MAX_WIDTH = 50;\n    const MIN_WIDTH = 10;\n    const columnWidths: number[] = headers.map((header) => Math.max(header.length, MIN_WIDTH));\n\n    for (const row of rows) {\n      const values = [row.key, row.source, ...locales.map((locale) => row[locale] ?? \"\")];\n      values.forEach((value, idx) => {\n        const textLength = String(value).length;\n        columnWidths[idx] = Math.min(Math.max(columnWidths[idx], textLength), MAX_WIDTH);\n      });\n    }\n\n    // 컬럼 너비 적용\n    for (let col = 0; col < columnWidths.length; col++) {\n      wb.setColWidth(sheet, colLetter(col), columnWidths[col] + 2);\n    }\n\n    return {\n      filename: `${projectName}-${new Date().toISOString().split(\"T\")[0]}.xlsx`,\n      buffer: wb.writeBufferSync(),\n    };\n  }\n\n  /**\n   * Excel에서 가져오기\n   *\n   * 형식:\n   * - 1행: 프로젝트명\n   * - 2행: 빈 행\n   * - 3행: 헤더 (key, source, locales...)\n   * - 4행 이후: 데이터\n   */\n  async importFromExcel(buffer: Buffer): Promise<ImportResult> {\n    const wb = Workbook.openBufferSync(buffer);\n    const sheet = wb.sheetNames[0];\n    const allRows = wb.getRows(sheet);\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    let updatedEntities = 0;\n    let updatedLocales = 0;\n\n    // locale별 project dict entries\n    const projectDictEntries: Record<string, DictEntry[]> = {};\n    for (const locale of locales) {\n      projectDictEntries[locale] = [];\n    }\n\n    // 헤더 행 찾기: 첫 번째 컬럼(A)이 \"key\"인 행\n    let headerRowNum = 0;\n    for (const rowData of allRows) {\n      const firstCell = rowData.cells.find((c) => c.column === \"A\");\n      const firstCellValue = String(firstCell?.value ?? \"\")\n        .trim()\n        .toLowerCase();\n      if (firstCellValue === \"key\") {\n        headerRowNum = rowData.row;\n        break;\n      }\n    }\n\n    if (headerRowNum === 0) {\n      throw new BadRequestException(SD(\"sonamu.error.headerRowNotFound\"));\n    }\n\n    // 헤더 행에서 컬럼 매핑 구성\n    const headerRowData = allRows.find((r) => r.row === headerRowNum);\n    const colToHeader: Map<string, string> = new Map();\n    if (headerRowData) {\n      for (const cell of headerRowData.cells) {\n        colToHeader.set(cell.column, String(cell.value ?? \"\"));\n      }\n    }\n\n    // 데이터 행 읽기 (헤더 다음 행부터)\n    for (const rowData of allRows) {\n      if (rowData.row <= headerRowNum) continue;\n\n      const rowValues: Record<string, string> = {};\n      for (const cell of rowData.cells) {\n        const headerName = colToHeader.get(cell.column);\n        if (headerName) {\n          rowValues[headerName] = String(cell.value ?? \"\");\n        }\n      }\n\n      const key = rowValues.key;\n      const source = rowValues.source as \"entity\" | \"project\";\n\n      if (!key || !source) continue;\n\n      if (source === \"entity\") {\n        // entity source: default locale만 entity.json에 저장\n        const defaultValue = rowValues[defaultLocale];\n        if (defaultValue) {\n          const updated = await this.updateEntityByKey(key, defaultValue);\n          if (updated) {\n            updatedEntities++;\n          }\n        }\n\n        // non-default locale은 project dict에 저장\n        for (const locale of locales) {\n          if (locale === defaultLocale) continue;\n          const cellValue = rowValues[locale]?.trim();\n          if (cellValue) {\n            projectDictEntries[locale].push({\n              key,\n              value: cellValue,\n              isFunction: this.isExpressionFunction(cellValue),\n            });\n          }\n        }\n      } else if (source === \"project\") {\n        // project source: 모든 locale을 project dict에 저장\n        for (const locale of locales) {\n          const cellValue = rowValues[locale]?.trim();\n          if (cellValue) {\n            projectDictEntries[locale].push({\n              key,\n              value: cellValue,\n              isFunction: this.isExpressionFunction(cellValue),\n            });\n          }\n        }\n      }\n    }\n\n    // Project dict 파일 생성\n    for (const locale of locales) {\n      const entries = projectDictEntries[locale];\n      if (entries.length > 0) {\n        await this.saveDictFile(locale, entries, locale === defaultLocale);\n        updatedLocales++;\n      }\n    }\n\n    return {\n      success: true,\n      updatedEntities,\n      updatedLocales,\n    };\n  }\n\n  /**\n   * 딕셔너리 항목 수정\n   */\n  async updateEntry(params: {\n    oldKey: string;\n    newKey: string;\n    source: \"entity\" | \"project\" | \"sonamu\";\n    values: Record<string, string>;\n  }): Promise<void> {\n    const { oldKey, newKey, source, values } = params;\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    // entity source의 default locale 처리\n    if (source === \"entity\" && values[defaultLocale]) {\n      await this.updateEntityByKey(newKey, values[defaultLocale]);\n    }\n\n    // project dict 업데이트\n    // - entity의 non-default locale\n    // - project source의 모든 locale\n    // - sonamu source의 모든 locale (override)\n    for (const locale of locales) {\n      // entity source의 default locale은 entity.json에서 처리했으므로 스킵\n      if (source === \"entity\" && locale === defaultLocale) continue;\n\n      const cellValue = values[locale]?.trim();\n      if (!cellValue) continue;\n\n      // 기존 dict 로드\n      const { entries } = this.loadProjectDict(locale);\n\n      // key 변경 시 기존 key 제거\n      if (oldKey !== newKey) {\n        const oldIndex = entries.findIndex((e) => e.key === oldKey);\n        if (oldIndex !== -1) {\n          entries.splice(oldIndex, 1);\n        }\n      }\n\n      // 새 값 업데이트 또는 추가\n      const existingIndex = entries.findIndex((e) => e.key === newKey);\n      const newEntry: DictEntry = {\n        key: newKey,\n        value: cellValue,\n        isFunction: this.isExpressionFunction(cellValue),\n      };\n\n      if (existingIndex !== -1) {\n        entries[existingIndex] = newEntry;\n      } else {\n        entries.push(newEntry);\n      }\n\n      // dict 파일 저장\n      await this.saveDictFile(locale, entries, locale === defaultLocale);\n    }\n  }\n\n  /**\n   * 딕셔너리 항목 추가\n   */\n  async createEntry(params: { key: string; values: Record<string, string> }): Promise<void> {\n    const { key, values } = params;\n\n    if (!key?.trim()) {\n      throw new BadRequestException(SD(\"sonamu.error.keyRequired\"));\n    }\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    // 중복 키 체크\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      if (entries.some((e) => e.key === key)) {\n        throw new BadRequestException(SD(\"sonamu.error.keyAlreadyExists\")(key));\n      }\n    }\n\n    // 각 locale에 새 키 추가\n    for (const locale of locales) {\n      const cellValue = values[locale]?.trim();\n      if (!cellValue) continue;\n\n      const { entries } = this.loadProjectDict(locale);\n      entries.push({\n        key,\n        value: cellValue,\n        isFunction: this.isExpressionFunction(cellValue),\n      });\n\n      await this.saveDictFile(locale, entries, locale === defaultLocale);\n    }\n  }\n\n  /**\n   * 딕셔너리 항목 삭제\n   */\n  async deleteEntry(key: string): Promise<void> {\n    if (!key) {\n      throw new BadRequestException(SD(\"sonamu.error.keyRequired\"));\n    }\n\n    const { defaultLocale, supportedLocales } = this.getI18nConfig();\n    const locales = supportedLocales;\n\n    let deleted = false;\n    for (const locale of locales) {\n      const { entries } = this.loadProjectDict(locale);\n      const index = entries.findIndex((e) => e.key === key);\n      if (index !== -1) {\n        entries.splice(index, 1);\n        deleted = true;\n\n        await this.saveDictFile(locale, entries, locale === defaultLocale);\n      }\n    }\n\n    if (!deleted) {\n      throw new BadRequestException(SD(\"sonamu.error.keyNotFound\")(key));\n    }\n  }\n\n  /**\n   * 미사용 키 검사 (ast-grep 사용)\n   */\n  async checkUsage(keys: string[]): Promise<UsageResult> {\n    // ast-grep 설치 확인\n    let sgPath: string | null = null;\n    try {\n      sgPath = execSync(\"which sg\", { encoding: \"utf-8\" }).trim();\n    } catch {\n      try {\n        sgPath = execSync(\"which ast-grep\", { encoding: \"utf-8\" }).trim();\n      } catch {\n        // ast-grep not installed\n      }\n    }\n\n    if (!sgPath) {\n      return {\n        error:\n          \"ast-grep이 설치되어 있지 않습니다. brew install ast-grep 또는 npm install -g @ast-grep/cli로 설치해주세요.\",\n        unusedKeys: [],\n      };\n    }\n\n    const searchPaths: string[] = [];\n    for (const entry of [\"api\", \"web\", \"app\"]) {\n      const srcPath = path.join(Sonamu.appRootPath, entry, \"src\");\n      if (fs.existsSync(srcPath)) {\n        searchPaths.push(srcPath);\n      }\n    }\n\n    if (searchPaths.length === 0) {\n      return {\n        error: \"검색할 src 디렉토리를 찾을 수 없습니다.\",\n        unusedKeys: [],\n      };\n    }\n\n    const usedKeys = new Set<string>();\n\n    try {\n      // ast-grep으로 SD(\"...\") 패턴 검색\n      // 패턴: SD(\"KEY\") 또는 SD('KEY') 형태\n      const patterns = ['SD(\"$KEY\")', \"SD('$KEY')\"];\n\n      for (const searchPath of searchPaths) {\n        for (const pattern of patterns) {\n          try {\n            const result = execSync(`${sgPath} --pattern '${pattern}' --json ${searchPath}`, {\n              encoding: \"utf-8\",\n              maxBuffer: 50 * 1024 * 1024, // 50MB\n            });\n\n            if (result.trim()) {\n              const matches = JSON.parse(result);\n              for (const match of matches) {\n                // metaVariables.single.KEY.text에서 키 추출\n                const keyText = match.metaVariables?.single?.KEY?.text;\n                if (keyText) {\n                  // 따옴표 제거\n                  const cleanKey = keyText.replace(/^[\"']|[\"']$/g, \"\");\n                  usedKeys.add(cleanKey);\n                }\n              }\n            }\n          } catch {\n            // 패턴 매치 없으면 에러 (무시)\n          }\n        }\n      }\n\n      // keys 중에서 usedKeys에 없는 것들이 미사용 키\n      const unusedKeys = keys.filter((k) => !usedKeys.has(k));\n\n      return { unusedKeys, usedKeysCount: usedKeys.size };\n    } catch (e) {\n      return {\n        error: `검색 중 오류 발생: ${e instanceof Error ? e.message : String(e)}`,\n        unusedKeys: [],\n      };\n    }\n  }\n}\n\nexport const sonamuDictionary = new SonamuDictionary();\n"],"mappings":"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"}