"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.excelToJsonPlugin = void 0;
// 由于Cocos Creator插件环境特殊，使用动态require方式
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const os = __importStar(require("os"));
const XLSX = __importStar(require("xlsx"));
class ExcelToJsonPlugin {
    constructor() {
        this.config = {
            excelPath: './配置表/excelList',
            jsonExportPath: './assets/bundles/first/config',
            tsExportPath: './assets/script/interface',
            autoExport: true,
            watcher: null
        };
        this.fileWatcher = null;
        // 消息处理
        this.messages = {
            'excel-to-json-ts:export-manual': () => {
                this.exportManual();
            }
        };
    }
    async load() {
        // 先执行一次导出
        await this.exportAllExcel();
        // 设置文件监听
        this.setupFileWatcher();
        // // 注册消息处理
        // Editor.Message.addBroadcastListener('excel-to-json-ts:profile-updated', () => {
        //     this.loadConfig();
        //     // 如果配置了自动导出，重新设置监听
        //     if (this.config.autoExport) {
        //         this.stopFileWatcher();
        //         this.setupFileWatcher();
        //         this.exportAllExcel(); // 配置保存后立即导出一次
        //     } else {
        //         this.stopFileWatcher();
        //     }
        // });
    }
    unload() {
        this.log('[Excel插件] 插件已卸载');
        this.stopFileWatcher();
    }
    // 加载配置
    async loadConfig() {
        try {
            let conf = await Editor.Profile.getProject('excel-to-json-ts');
            if (conf)
                this.config = conf;
            else {
                Editor.Profile.setProject('excel-to-json-ts', "excelPath", this.config.excelPath);
                Editor.Profile.setProject('excel-to-json-ts', "jsonExportPath", this.config.jsonExportPath);
                Editor.Profile.setProject('excel-to-json-ts', "tsExportPath", this.config.tsExportPath);
                this.warn(`[Excel插件] 路径配置不正确`);
            }
            this.log('[Excel插件] 配置已加载');
            this.log('[Excel插件] excelPath' + this.config.excelPath);
            this.log('[Excel插件] jsonPath' + this.config.jsonExportPath);
            this.log('[Excel插件] tsPath' + this.config.tsExportPath);
        }
        catch (err) {
            this.error(`[Excel插件] 加载配置失败: ${err}`);
        }
    }
    // 手动导出
    exportManual() {
        this.exportAllExcel();
    }
    // 导出所有Excel（增强健壮性）
    async exportAllExcel() {
        await this.loadConfig();
        if (!this.config.excelPath) {
            this.error('[Excel插件] Excel目录路径未配置');
            return;
        }
        if (!fs.existsSync(this.config.excelPath)) {
            this.error(`[Excel插件] Excel目录不存在: ${this.config.excelPath}`);
            return;
        }
        try {
            // 确保导出目录存在
            if (this.config.jsonExportPath && !fs.existsSync(this.config.jsonExportPath)) {
                fs.mkdirSync(this.config.jsonExportPath, { recursive: true });
            }
            if (this.config.tsExportPath && !fs.existsSync(this.config.tsExportPath)) {
                fs.mkdirSync(this.config.tsExportPath, { recursive: true });
            }
            // 获取目录中所有Excel文件
            const excelFiles = this.getExcelFilesInDirectory(this.config.excelPath);
            if (excelFiles.length === 0) {
                this.warn(`[Excel插件] 目录中没有找到Excel文件: ${this.config.excelPath}`);
                return;
            }
            this.log(`[Excel插件] 找到 ${excelFiles.length} 个Excel文件`);
            let successCount = 0;
            let errorCount = 0;
            // 处理每个Excel文件
            for (const excelFile of excelFiles) {
                try {
                    this.processExcelFile(excelFile);
                    successCount++;
                }
                catch (err) {
                    this.error(`[Excel插件] 处理文件失败 ${path.basename(excelFile)}: ${err}`);
                    errorCount++;
                }
            }
            if (successCount > 0) {
                this.refreshAssetDatabase();
                this.success(`[Excel插件] 导出完成，成功处理 ${successCount} 个文件，失败 ${errorCount} 个`);
            }
            else {
                this.error(`[Excel插件] 导出失败，没有成功处理任何文件`);
            }
        }
        catch (err) {
            this.error(`[Excel插件] 导出失败: ${err}`);
        }
    }
    // 获取目录中的所有Excel文件
    getExcelFilesInDirectory(dirPath) {
        return fs.readdirSync(dirPath)
            .filter(file => {
            // 过滤隐藏文件（以点开头的文件）
            if (file.startsWith('.') || file.startsWith('~')) {
                return false;
            }
            const ext = path.extname(file).toLowerCase();
            return (ext === '.xlsx' || ext === '.xls') &&
                fs.statSync(path.join(dirPath, file)).isFile();
        })
            .map(file => path.join(dirPath, file));
    }
    // 处理单个Excel文件
    processExcelFile(filePath) {
        try {
            // 安全读取打开状态的Excel文件
            const workbook = this.readExcelSafely(filePath);
            const sheetNames = workbook.SheetNames;
            // 导出每个工作表
            for (const sheetName of sheetNames) {
                if (sheetName.match("Sheet") || !sheetName.match("|")) {
                    continue;
                }
                this.exportSheet(workbook, sheetName, filePath);
            }
        }
        catch (err) {
            throw new Error(`处理文件 ${path.basename(filePath)} 失败: ${err}`);
        }
    }
    // 安全读取打开状态的Excel文件（终极版）
    readExcelSafely(filePath) {
        const tempPath = path.join(os.tmpdir(), `excel-temp-${Date.now()}-${path.basename(filePath)}`);
        try {
            // 详细记录文件状态
            const stats = fs.statSync(filePath);
            // this.log(`[Excel插件] 尝试读取文件 - 大小: ${stats.size} bytes, 最后修改: ${new Date(stats.mtimeMs).toLocaleTimeString()}`);
            // 尝试复制文件，带详细错误处理
            try {
                fs.copyFileSync(filePath, tempPath);
            }
            catch (copyErr) {
                this.warn(`[Excel插件] 第一次复制失败: ${copyErr}`);
                // 再次尝试，有时第一次会失败
                try {
                    fs.copyFileSync(filePath, tempPath);
                }
                catch (finalErr) {
                    this.error(`[Excel插件] 两次复制尝试均失败: ${finalErr}`);
                    throw finalErr;
                }
            }
            // 验证临时文件
            const tempStats = fs.statSync(tempPath);
            if (tempStats.size === 0) {
                throw new Error("临时文件大小为0，复制可能未完成");
            }
            return XLSX.readFile(tempPath);
        }
        catch (err) {
            throw new Error(`读取Excel失败: ${err.message || err}`);
        }
        finally {
            // 确保清理临时文件
            try {
                if (fs.existsSync(tempPath)) {
                    fs.unlinkSync(tempPath);
                }
            }
            catch (e) {
                this.warn(`[Excel插件] 无法删除临时文件: ${tempPath} - ${e}`);
            }
        }
    }
    // 导出单个工作表
    exportSheet(workbook, sheetName, filePath) {
        try {
            const worksheet = workbook.Sheets[sheetName];
            const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
            // 检查是否有足够的表头行（至少3行：字段名、类型、说明）
            if (jsonData.length < 3) {
                this.warn(`[Excel插件] 工作表 "${sheetName}" 数据不足，跳过导出 (文件: ${path.basename(filePath)})的${sheetName}`);
                return;
            }
            if (!sheetName.match("|") || sheetName.split("|").length < 2) {
                this.warn(`[Excel插件] 工作表 "${sheetName}" 名称格式错误，跳过导出 (文件: ${path.basename(filePath)})的${sheetName}`);
                return;
            }
            const sName = sheetName.split("|")[1];
            // 提取表头信息
            const headers = {
                fields: jsonData[0],
                types: jsonData[1],
                descriptions: jsonData[2]
            };
            // 从第4行开始是数据
            const dataRows = jsonData.slice(3);
            // 生成JSON数据
            const jsonResult = this.generateJsonData(dataRows, headers);
            // 生成TS接口
            const tsInterface = this.generateTSInterface(sName, headers);
            // 生成文件名
            const safeSheetName = this.makeSafeFileName(sName);
            const jsonFileName = `${safeSheetName}.json`;
            //const tsFileName = `ITable${safeSheetName}.ts`;
            const tsFileName = `AutoTable.ts`;
            // 写入JSON文件
            if (this.config.jsonExportPath) {
                const jsonPath = path.join(this.config.jsonExportPath, jsonFileName);
                fs.writeFileSync(jsonPath, JSON.stringify(jsonResult, null, 4), 'utf-8');
            }
            // 写入TS文件
            if (this.config.tsExportPath) {
                const tsPath = path.join(this.config.tsExportPath, tsFileName);
                let tsContent = "";
                try {
                    if (fs.existsSync(tsPath)) {
                        tsContent = fs.readFileSync(tsPath, 'utf-8');
                    }
                }
                catch (err) {
                    this.warn(`[Excel插件] 读取TS文件失败: ${err}`);
                }
                if (tsContent == "") {
                    tsContent = "declare global {\n\n}\nexport { };";
                }
                if (this.extractFullInterfaceBlock(tsContent, "ITable" + sName)) {
                    //console.log("替换接口:" + sName + "，内容：" + tsInterface);
                    tsContent = this.replaceInterfaceBlock(tsContent, "ITable" + sName, tsInterface);
                }
                else {
                    //console.log("加到末尾：" + tsInterface);
                    tsContent = tsContent.replace(/}\nexport { };$/, tsInterface + "}\nexport { };");
                }
                fs.writeFileSync(tsPath, tsContent, 'utf-8');
            }
        }
        catch (err) {
            throw new Error(`工作表 "${sheetName}" 导出失败 (文件: ${path.basename(filePath)}): ${err}`);
        }
    }
    /**
     * 转义正则特殊字符
     */
    escapeRegExp(str) {
        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    }
    /**
     * 精准查找接口声明行（全字匹配）
     */
    findInterfaceDeclarationLine(fileContent, interfaceName) {
        // 使用单词边界 \b 确保全字匹配
        const regex = new RegExp(`\\binterface\\s+${this.escapeRegExp(interfaceName)}\\b(?:\\s*<[^>]*>)?\\s*[\\{\\n]`, 'g');
        let match;
        while ((match = regex.exec(fileContent)) !== null) {
            // 找到匹配位置，确定完整行
            const matchStart = match.index;
            // 向前找到行开始
            const lineStart = fileContent.lastIndexOf('\n', matchStart - 1) + 1;
            // 向后找到行结束
            const lineEnd = fileContent.indexOf('\n', matchStart);
            const actualLineEnd = lineEnd === -1 ? fileContent.length : lineEnd;
            const lineContent = fileContent.substring(lineStart, actualLineEnd);
            // 验证：确保这一行确实是我们的目标接口
            if (lineContent.trim().startsWith(`interface ${interfaceName}`)) {
                return {
                    lineStart,
                    lineEnd: actualLineEnd,
                    lineContent
                };
            }
        }
        return null;
    }
    /**
     * 提取完整的接口块（包括上方注释）
     */
    extractFullInterfaceBlock(fileContent, interfaceName) {
        const interfaceLine = this.findInterfaceDeclarationLine(fileContent, interfaceName);
        if (!interfaceLine) {
            return null;
        }
        // === 向前查找连续的注释块 ===
        let blockStart = interfaceLine.lineStart;
        let currentPos = interfaceLine.lineStart;
        while (currentPos > 0) {
            const prevLineEnd = currentPos - 1;
            const prevLineStart = fileContent.lastIndexOf('\n', prevLineEnd - 1) + 1;
            const prevLine = fileContent.substring(prevLineStart, prevLineEnd).trim();
            // 检查是否为注释行或空行
            if (prevLine === '' ||
                prevLine.startsWith('//') ||
                prevLine.startsWith('/*') ||
                prevLine.startsWith('*')) {
                currentPos = prevLineStart;
            }
            else {
                blockStart = currentPos;
                break;
            }
        }
        if (currentPos === 0) {
            blockStart = 0;
        }
        // === 向后查找接口体结束 ===
        // 找到 interface 行中的开括号位置
        const openBraceIndex = interfaceLine.lineContent.indexOf('{');
        let startPos = interfaceLine.lineStart;
        let braceCount = 0;
        if (openBraceIndex !== -1) {
            // 开括号在同一行
            startPos = interfaceLine.lineStart + openBraceIndex;
            braceCount = 1;
        }
        else {
            // 开括号在下一行，找到第一个 {
            const nextOpenBrace = fileContent.indexOf('{', interfaceLine.lineEnd);
            if (nextOpenBrace === -1)
                return null;
            startPos = nextOpenBrace;
            braceCount = 1;
        }
        let pos = startPos + 1; // 跳过 {
        while (pos < fileContent.length && braceCount > 0) {
            if (fileContent[pos] === '{') {
                braceCount++;
            }
            else if (fileContent[pos] === '}') {
                braceCount--;
            }
            pos++;
        }
        if (braceCount !== 0) {
            return null; // 括号不匹配
        }
        const blockEnd = pos;
        const fullContent = fileContent.substring(blockStart, blockEnd);
        return {
            start: blockStart,
            end: blockEnd,
            content: fullContent
        };
    }
    /**
     * 完全替换接口块（全字匹配，精准替换）
     */
    replaceInterfaceBlock(fileContent, interfaceName, newInterfaceBlock) {
        const blockInfo = this.extractFullInterfaceBlock(fileContent, interfaceName);
        if (!blockInfo) {
            throw new Error(`❌ 接口 "${interfaceName}" 未找到！请检查名称是否正确。`);
        }
        // 验证：确保提取的块确实只包含目标接口
        const interfaceLines = blockInfo.content.split('\n');
        const interfaceDeclLines = interfaceLines.filter(line => line.trim().startsWith('interface '));
        if (interfaceDeclLines.length !== 1) {
            throw new Error(`❌ 找到多个 interface 声明，可能匹配错误！`);
        }
        if (!interfaceDeclLines[0].includes(`interface ${interfaceName}`)) {
            throw new Error(`❌ 匹配到错误的接口名称！`);
        }
        //console.log(`✅ 精准匹配到接口 "${interfaceName}"`);
        return (fileContent.substring(0, blockInfo.start) +
            newInterfaceBlock +
            fileContent.substring(blockInfo.end));
    }
    // 设置文件监听（终极版）
    setupFileWatcher() {
        this.stopFileWatcher();
        if (!this.config.excelPath)
            return;
        if (!fs.existsSync(this.config.excelPath)) {
            this.error(`[Excel插件] 监听目录不存在: ${this.config.excelPath}`);
            return;
        }
        try {
            // 使用更可靠的监听方式
            this.fileWatcher = fs.watch(this.config.excelPath, {
                recursive: false,
                encoding: 'utf8'
            }, async (eventType, filename) => {
                if (!filename)
                    return;
                this.loadConfig();
                if (this.config.autoExport == false)
                    return;
                // 确保是字符串
                const fileNameStr = typeof filename === 'string' ? filename : filename + "";
                const ext = path.extname(fileNameStr).toLowerCase();
                if (ext === '.xlsx' || ext === '.xls') {
                    const filePath = path.join(this.config.excelPath, fileNameStr);
                    // 额外验证：确保是文件且存在
                    try {
                        if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
                            this.log(`[Excel插件] 检测到文件变更: ${fileNameStr} (${eventType})`);
                            // 使用终极重试机制
                            // 重试次数增加到8，基础延迟1秒
                            this.processExcelFileWithRetry(filePath, 8, 1000);
                        }
                    }
                    catch (err) {
                        this.warn(`[Excel插件] 验证文件状态时出错: ${err}`);
                    }
                }
            });
            // 处理监听错误
            if (this.fileWatcher && typeof this.fileWatcher.on === 'function') {
                this.fileWatcher.on('error', (error) => {
                    this.error(`[Excel插件] 文件监听错误: ${error}`);
                    // 尝试重新设置监听
                    setTimeout(() => {
                        this.stopFileWatcher();
                        this.setupFileWatcher();
                    }, 15000);
                });
            }
            this.log('[Excel插件] 已启动Excel目录监听（终极版）');
        }
        catch (err) {
            this.error(`[Excel插件] 目录监听失败: ${err}`);
            // 尝试重新设置监听
            setTimeout(() => {
                this.stopFileWatcher();
                this.setupFileWatcher();
            }, 20000);
        }
    }
    // 带终极重试机制处理Excel文件
    processExcelFileWithRetry(filePath, maxRetries = 8, baseDelay = 1000) {
        let attempt = 0;
        const startTime = Date.now();
        const tryProcess = () => {
            attempt++;
            const elapsed = Date.now() - startTime;
            const delay = baseDelay * Math.min(1.5 ** (attempt - 1), 4); // 指数退避，但上限为4倍基础延迟
            this.log(`[Excel插件] 处理文件 "${path.basename(filePath)}" - 尝试 ${attempt}/${maxRetries} (延迟 ${Math.round(delay)}ms, 已耗时 ${Math.round(elapsed / 1000)}s)`);
            setTimeout(() => {
                try {
                    // 额外检查文件是否可读
                    const stats = fs.statSync(filePath);
                    if (stats.size === 0) {
                        throw new Error("文件大小为0，可能仍在写入");
                    }
                    // 检查文件最后修改时间，确保不是刚被修改
                    const now = Date.now();
                    const fileAge = now - stats.mtimeMs;
                    if (fileAge < 2000) { // 文件修改时间少于2秒，可能还在写入
                        throw new Error(`文件刚被修改 (${Math.round(fileAge)}ms前)，可能仍在写入`);
                    }
                    this.processExcelFile(filePath);
                    const totalTime = Date.now() - startTime;
                    this.refreshAssetDatabase();
                    this.success(`[Excel插件] 文件 "${path.basename(filePath)}" 自动导出成功 (总耗时 ${Math.round(totalTime / 1000)}s, 尝试 ${attempt}/${maxRetries})`);
                }
                catch (err) {
                    // 详细记录错误
                    this.warn(`[Excel插件] 尝试 ${attempt} 失败: ${err.message || err}`);
                    // 检查是否是文件锁定或权限错误
                    const isFileLockError = err.message && (err.message.includes('EPERM') ||
                        err.message.includes('EBUSY') ||
                        err.message.includes('permission') ||
                        err.message.includes('locked') ||
                        err.message.includes('EACCES') ||
                        err.message.includes('file size 0') ||
                        err.message.includes('刚被修改'));
                    if (isFileLockError && attempt < maxRetries) {
                        // 计算下一次尝试的延迟（指数退避）
                        const nextDelay = baseDelay * Math.min(1.5 ** attempt, 4);
                        this.warn(`[Excel插件] 文件 "${path.basename(filePath)}" 可能仍在保存中，将在 ${Math.round(nextDelay)}ms 后重试 (尝试 ${attempt + 1}/${maxRetries})`);
                        setTimeout(tryProcess, nextDelay);
                    }
                    else {
                        const totalTime = Date.now() - startTime;
                        this.error(`[Excel插件] 文件 "${path.basename(filePath)}" 自动导出失败 (总耗时 ${Math.round(totalTime / 1000)}s): ${err}`);
                        // 如果是文件锁定错误但已达到最大重试次数，提供具体建议
                        if (isFileLockError) {
                            this.error(`[Excel插件] 建议: 确保Excel完全保存后再进行修改，或增加重试次数和延迟`);
                        }
                    }
                }
            }, delay);
        };
        // 开始第一次尝试
        tryProcess();
    }
    // 停止文件监听（更新）
    stopFileWatcher() {
        if (this.fileWatcher) {
            try {
                // 使用类型断言确保调用close方法
                this.fileWatcher.close();
                this.fileWatcher = null;
            }
            catch (e) {
                this.warn(`[Excel插件] 停止监听时出错: ${e}`);
            }
            if (this.config.watcher) {
                clearTimeout(this.config.watcher);
                this.config.watcher = null;
            }
            this.log('[Excel插件] 已停止Excel文件监听');
        }
    }
    // 生成JSON数据
    generateJsonData(dataRows, headers) {
        const result = [];
        for (const row of dataRows) {
            const obj = {};
            for (let i = 0; i < headers.fields.length; i++) {
                const field = headers.fields[i];
                const type = headers.types[i];
                if (field) {
                    // 处理空单元格，使用对应类型的默认值
                    const value = row[i] !== undefined ? row[i] : this.getDefaultValue(type);
                    obj[field] = this.convertValue(value, type);
                }
            }
            result.push(obj);
        }
        return result;
    }
    // 根据类型获取默认值
    getDefaultValue(type) {
        if (!type)
            return null;
        const cleanType = type.toLowerCase().trim();
        switch (cleanType) {
            case 'int':
            case 'float':
                return 0;
            case 'boolean':
                return false;
            case 'int[]':
            case 'float[]':
            case 'string[]':
            case 'any[]':
                return [];
            case 'string':
                return '';
            default:
                return '';
        }
    }
    // 类型转换
    convertValue(value, type) {
        if (value === null || value === undefined)
            return null;
        const cleanType = type.toLowerCase().trim();
        try {
            switch (cleanType) {
                case 'int':
                    return parseInt(value);
                case 'float':
                    return parseFloat(value);
                case 'json':
                    return JSON.parse(value);
                case 'boolean':
                    return value.toString().toLowerCase() === 'true' || value === 1;
                case 'int[]':
                    return this.parseArray(value, 'int');
                case 'float[]':
                    return this.parseArray(value, 'float');
                case 'string[]':
                    return this.parseArray(value, 'string');
                case 'any[]':
                    return this.parseArray(value, 'any');
                default:
                    return value;
            }
        }
        catch (e) {
            this.warn(`[Excel插件] 类型转换失败 [${type}]: ${value} - ${e}`);
            return value;
        }
    }
    // 解析数组
    parseArray(value, targetType) {
        if (Array.isArray(value))
            return value;
        // 尝试分割字符串
        let items = [];
        if (typeof value === 'string') {
            items = value.split(/[,;#\s]\s*/).filter(v => v);
        }
        else {
            items = [value];
        }
        return items.map(item => {
            if (targetType === 'any') {
                // 自动识别类型
                if (!isNaN(item)) {
                    return !isNaN(parseFloat(item)) ? parseFloat(item) : parseInt(item);
                }
                if (item.toLowerCase() === 'true' || item.toLowerCase() === 'false') {
                    return item.toLowerCase() === 'true';
                }
                return item;
            }
            // 指定类型转换
            switch (targetType) {
                case 'int': return parseInt(item);
                case 'float': return parseFloat(item);
                case 'string': return String(item);
                default: return item;
            }
        });
    }
    generateTSInterfaceStart(sheetName) {
        const interfaceName = `ITable${sheetName}`;
        const safeSheetName = `${this.makeSafeFileName(sheetName)}`;
        let tsContent = `    /**\n     * ${safeSheetName} 配置数据\n    */\n`;
        tsContent += `    interface ${interfaceName} {\n`;
        return tsContent;
    }
    // 生成TS接口
    generateTSInterface(sheetName, headers) {
        const interfaceName = `ITable${sheetName}`;
        const safeSheetName = `${this.makeSafeFileName(sheetName)}`;
        let tsContent = `    /**\n     * ${safeSheetName} 配置数据\n    */\n`;
        tsContent += `    interface ${interfaceName} {\n`;
        for (let i = 0; i < headers.fields.length; i++) {
            const field = headers.fields[i];
            const type = headers.types[i];
            const description = headers.descriptions[i] || '字段说明';
            if (field) {
                tsContent += `        /** ${description} */\n`;
                tsContent += `        readonly ${field}: ${this.convertToTSType(type)};\n`;
            }
        }
        tsContent += `    }\n`;
        return tsContent;
    }
    // 转换为TS类型
    convertToTSType(excelType) {
        if (!excelType)
            return 'any';
        const type = excelType.toLowerCase().trim();
        switch (type) {
            case 'string':
                return 'string';
            case 'int':
            case 'float':
                return 'number';
            case 'boolean':
                return 'boolean';
            case 'int[]':
                return 'number[]';
            case 'float[]':
                return 'number[]';
            case 'string[]':
                return 'string[]';
            case 'any[]':
                return '(number | string | boolean)[]';
            default:
                return 'any';
        }
    }
    // 转换为PascalCase
    toPascalCase(str) {
        return str.replace(/(\w)(\w*)/g, (_, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/[^a-zA-Z0-9]/g, '');
    }
    // 创建安全的文件名
    makeSafeFileName(name) {
        return name.replace(/[^a-zA-Z0-9_]/g, '_');
    }
    // 日志输出
    log(message) {
        console.log(message);
    }
    error(message) {
        console.error(message);
    }
    warn(message) {
        console.warn(message);
    }
    success(message) {
        console.log(message);
    }
    // 刷新资源管理器
    async refreshAssetDatabase() {
        try {
            // 确保路径是项目内的路径（db://assets/开头）
            const jsonDbPath = this.convertToDbPath(this.config.jsonExportPath);
            const tsDbPath = this.convertToDbPath(this.config.tsExportPath);
            // 刷新JSON导出目录
            if (jsonDbPath && jsonDbPath.startsWith('db://')) {
                await Editor.Message.request('asset-db', 'refresh-asset', jsonDbPath);
            }
            // 刷新TS导出目录
            if (tsDbPath && tsDbPath.startsWith('db://')) {
                await Editor.Message.request('asset-db', 'refresh-asset', tsDbPath);
            }
            this.success('[Excel插件] 资源刷新请求已发送');
        }
        catch (err) {
            this.error(`[Excel插件] 资源刷新失败: ${err}`);
        }
    }
    // 将系统路径转换为Cocos的db路径
    convertToDbPath(systemPath) {
        if (!systemPath)
            return '';
        try {
            // 获取项目路径
            const projectPath = Editor.Project.path;
            // 规范化路径（统一使用正斜杠）
            systemPath = systemPath.replace(/\\/g, '/');
            const normalizedProjectPath = projectPath.replace(/\\/g, '/');
            // 确保路径以/结尾
            const projectPathWithSlash = normalizedProjectPath.endsWith('/')
                ? normalizedProjectPath
                : normalizedProjectPath + '/';
            // 检查是否在项目目录内
            if (systemPath.startsWith(projectPathWithSlash)) {
                // 计算相对路径
                const relativePath = systemPath.substring(projectPathWithSlash.length);
                return `db://${relativePath}`;
            }
            // 如果路径包含assets目录，尝试直接转换
            if (systemPath.includes('/assets/') || systemPath.includes('\\assets\\')) {
                const assetsIndex = systemPath.toLowerCase().indexOf('/assets/');
                if (assetsIndex !== -1) {
                    const relativeToAssets = systemPath.substring(assetsIndex + 1);
                    return `db://${relativeToAssets}`;
                }
            }
            this.warn(`[Excel插件] 路径不在项目内，可能无法正确刷新: ${systemPath}`);
            return systemPath;
        }
        catch (err) {
            this.error(`[Excel插件] 路径转换失败: ${err}`);
            return systemPath;
        }
    }
}
exports.excelToJsonPlugin = new ExcelToJsonPlugin();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"excel2jsonAndTs.js","sourceRoot":"","sources":["../source/excel2jsonAndTs.ts"],"names":[],"mappings":"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","sourcesContent":["// 由于Cocos Creator插件环境特殊，使用动态require方式\r\nimport * as fs from 'fs';\r\nimport * as path from 'path';\r\nimport * as os from 'os';\r\nimport * as XLSX from 'xlsx';\r\nimport * as chokidar from 'chokidar'; // 补充导入chokidar模块\r\n\r\n\r\n// 定义类型以提高代码可读性\r\ninterface PluginConfig {\r\n    excelPath: string;\r\n    jsonExportPath: string;\r\n    tsExportPath: string;\r\n    autoExport: boolean;\r\n    watcher: any;\r\n}\r\n\r\nclass ExcelToJsonPlugin {\r\n    private config: PluginConfig = {\r\n        excelPath: './配置表/excelList',\r\n        jsonExportPath: './assets/bundles/first/config',\r\n        tsExportPath: './assets/script/interface',\r\n        autoExport: true,\r\n        watcher: null\r\n    };\r\n\r\n    private fileWatcher: fs.FSWatcher | null = null;\r\n\r\n    async load() {\r\n\r\n        // 先执行一次导出\r\n        await this.exportAllExcel();\r\n\r\n        // 设置文件监听\r\n        this.setupFileWatcher();\r\n\r\n\r\n        // // 注册消息处理\r\n        // Editor.Message.addBroadcastListener('excel-to-json-ts:profile-updated', () => {\r\n        //     this.loadConfig();\r\n\r\n        //     // 如果配置了自动导出，重新设置监听\r\n        //     if (this.config.autoExport) {\r\n        //         this.stopFileWatcher();\r\n        //         this.setupFileWatcher();\r\n        //         this.exportAllExcel(); // 配置保存后立即导出一次\r\n        //     } else {\r\n        //         this.stopFileWatcher();\r\n        //     }\r\n        // });\r\n    }\r\n\r\n    unload() {\r\n        this.log('[Excel插件] 插件已卸载');\r\n        this.stopFileWatcher();\r\n    }\r\n\r\n    // 加载配置\r\n    async loadConfig() {\r\n        try {\r\n            let conf = await Editor.Profile.getProject('excel-to-json-ts');\r\n            if (conf)\r\n                this.config = conf;\r\n            else {\r\n                Editor.Profile.setProject('excel-to-json-ts', \"excelPath\", this.config.excelPath);\r\n                Editor.Profile.setProject('excel-to-json-ts', \"jsonExportPath\", this.config.jsonExportPath);\r\n                Editor.Profile.setProject('excel-to-json-ts', \"tsExportPath\", this.config.tsExportPath);\r\n                this.warn(`[Excel插件] 路径配置不正确`);\r\n            }\r\n            this.log('[Excel插件] 配置已加载');\r\n            this.log('[Excel插件] excelPath' + this.config.excelPath);\r\n            this.log('[Excel插件] jsonPath' + this.config.jsonExportPath);\r\n            this.log('[Excel插件] tsPath' + this.config.tsExportPath);\r\n\r\n        } catch (err) {\r\n            this.error(`[Excel插件] 加载配置失败: ${err}`);\r\n        }\r\n    }\r\n\r\n    // 手动导出\r\n    exportManual() {\r\n        this.exportAllExcel();\r\n    }\r\n\r\n    // 导出所有Excel（增强健壮性）\r\n    async exportAllExcel() {\r\n        await this.loadConfig();\r\n\r\n        if (!this.config.excelPath) {\r\n            this.error('[Excel插件] Excel目录路径未配置');\r\n            return;\r\n        }\r\n\r\n        if (!fs.existsSync(this.config.excelPath)) {\r\n            this.error(`[Excel插件] Excel目录不存在: ${this.config.excelPath}`);\r\n            return;\r\n        }\r\n\r\n        try {\r\n            // 确保导出目录存在\r\n            if (this.config.jsonExportPath && !fs.existsSync(this.config.jsonExportPath)) {\r\n                fs.mkdirSync(this.config.jsonExportPath, { recursive: true });\r\n            }\r\n            if (this.config.tsExportPath && !fs.existsSync(this.config.tsExportPath)) {\r\n                fs.mkdirSync(this.config.tsExportPath, { recursive: true });\r\n            }\r\n\r\n            // 获取目录中所有Excel文件\r\n            const excelFiles = this.getExcelFilesInDirectory(this.config.excelPath);\r\n\r\n            if (excelFiles.length === 0) {\r\n                this.warn(`[Excel插件] 目录中没有找到Excel文件: ${this.config.excelPath}`);\r\n                return;\r\n            }\r\n\r\n            this.log(`[Excel插件] 找到 ${excelFiles.length} 个Excel文件`);\r\n\r\n            let successCount = 0;\r\n            let errorCount = 0;\r\n\r\n            // 处理每个Excel文件\r\n            for (const excelFile of excelFiles) {\r\n                try {\r\n                    this.processExcelFile(excelFile);\r\n                    successCount++;\r\n                } catch (err) {\r\n                    this.error(`[Excel插件] 处理文件失败 ${path.basename(excelFile)}: ${err}`);\r\n                    errorCount++;\r\n                }\r\n            }\r\n\r\n            if (successCount > 0) {\r\n                this.refreshAssetDatabase();\r\n                this.success(`[Excel插件] 导出完成，成功处理 ${successCount} 个文件，失败 ${errorCount} 个`);\r\n\r\n            } else {\r\n                this.error(`[Excel插件] 导出失败，没有成功处理任何文件`);\r\n            }\r\n        } catch (err) {\r\n            this.error(`[Excel插件] 导出失败: ${err}`);\r\n        }\r\n    }\r\n\r\n\r\n    // 获取目录中的所有Excel文件\r\n    getExcelFilesInDirectory(dirPath: string): string[] {\r\n        return fs.readdirSync(dirPath)\r\n            .filter(file => {\r\n                // 过滤隐藏文件（以点开头的文件）\r\n                if (file.startsWith('.') || file.startsWith('~')) {\r\n                    return false;\r\n                }\r\n                const ext = path.extname(file).toLowerCase();\r\n                return (ext === '.xlsx' || ext === '.xls') &&\r\n                    fs.statSync(path.join(dirPath, file)).isFile();\r\n            })\r\n            .map(file => path.join(dirPath, file));\r\n    }\r\n\r\n    // 处理单个Excel文件\r\n    processExcelFile(filePath: string) {\r\n        try {\r\n            // 安全读取打开状态的Excel文件\r\n            const workbook = this.readExcelSafely(filePath);\r\n            const sheetNames = workbook.SheetNames;\r\n\r\n            // 导出每个工作表\r\n            for (const sheetName of sheetNames) {\r\n                if (sheetName.match(\"Sheet\") || !sheetName.match(\"|\")) {\r\n                    continue;\r\n                }\r\n                this.exportSheet(workbook, sheetName, filePath);\r\n            }\r\n        } catch (err) {\r\n            throw new Error(`处理文件 ${path.basename(filePath)} 失败: ${err}`);\r\n        }\r\n    }\r\n\r\n    // 安全读取打开状态的Excel文件（终极版）\r\n    readExcelSafely(filePath: string): any {\r\n        const tempPath = path.join(os.tmpdir(), `excel-temp-${Date.now()}-${path.basename(filePath)}`);\r\n\r\n        try {\r\n            // 详细记录文件状态\r\n            const stats = fs.statSync(filePath);\r\n            // this.log(`[Excel插件] 尝试读取文件 - 大小: ${stats.size} bytes, 最后修改: ${new Date(stats.mtimeMs).toLocaleTimeString()}`);\r\n\r\n            // 尝试复制文件，带详细错误处理\r\n            try {\r\n                fs.copyFileSync(filePath, tempPath);\r\n            } catch (copyErr) {\r\n                this.warn(`[Excel插件] 第一次复制失败: ${copyErr}`);\r\n\r\n                // 再次尝试，有时第一次会失败\r\n                try {\r\n                    fs.copyFileSync(filePath, tempPath);\r\n                } catch (finalErr) {\r\n                    this.error(`[Excel插件] 两次复制尝试均失败: ${finalErr}`);\r\n                    throw finalErr;\r\n                }\r\n            }\r\n\r\n            // 验证临时文件\r\n            const tempStats = fs.statSync(tempPath);\r\n            if (tempStats.size === 0) {\r\n                throw new Error(\"临时文件大小为0，复制可能未完成\");\r\n            }\r\n\r\n            return XLSX.readFile(tempPath);\r\n        } catch (err: any) {\r\n            throw new Error(`读取Excel失败: ${err.message || err}`);\r\n        } finally {\r\n            // 确保清理临时文件\r\n            try {\r\n                if (fs.existsSync(tempPath)) {\r\n                    fs.unlinkSync(tempPath);\r\n                }\r\n            } catch (e) {\r\n                this.warn(`[Excel插件] 无法删除临时文件: ${tempPath} - ${e}`);\r\n            }\r\n        }\r\n    }\r\n\r\n    // 导出单个工作表\r\n    exportSheet(workbook: any, sheetName: string, filePath: string) {\r\n        try {\r\n            const worksheet = workbook.Sheets[sheetName];\r\n            const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });\r\n\r\n            // 检查是否有足够的表头行（至少3行：字段名、类型、说明）\r\n            if (jsonData.length < 3) {\r\n                this.warn(`[Excel插件] 工作表 \"${sheetName}\" 数据不足，跳过导出 (文件: ${path.basename(filePath)})的${sheetName}`);\r\n                return;\r\n            }\r\n\r\n            if (!sheetName.match(\"|\") || sheetName.split(\"|\").length < 2) {\r\n                this.warn(`[Excel插件] 工作表 \"${sheetName}\" 名称格式错误，跳过导出 (文件: ${path.basename(filePath)})的${sheetName}`);\r\n                return;\r\n            }\r\n\r\n            const sName = sheetName.split(\"|\")[1];\r\n\r\n            // 提取表头信息\r\n            const headers = {\r\n                fields: jsonData[0],\r\n                types: jsonData[1],\r\n                descriptions: jsonData[2]\r\n            };\r\n\r\n            // 从第4行开始是数据\r\n            const dataRows = jsonData.slice(3) as any[][];\r\n\r\n            // 生成JSON数据\r\n            const jsonResult = this.generateJsonData(dataRows, headers);\r\n\r\n            // 生成TS接口\r\n            const tsInterface = this.generateTSInterface(sName, headers);\r\n\r\n            // 生成文件名\r\n            const safeSheetName = this.makeSafeFileName(sName);\r\n\r\n            const jsonFileName = `${safeSheetName}.json`;\r\n            //const tsFileName = `ITable${safeSheetName}.ts`;\r\n            const tsFileName = `AutoTable.ts`;\r\n\r\n            // 写入JSON文件\r\n            if (this.config.jsonExportPath) {\r\n                const jsonPath = path.join(this.config.jsonExportPath, jsonFileName);\r\n                fs.writeFileSync(jsonPath, JSON.stringify(jsonResult, null, 4), 'utf-8');\r\n            }\r\n\r\n            // 写入TS文件\r\n            if (this.config.tsExportPath) {\r\n                const tsPath = path.join(this.config.tsExportPath, tsFileName);\r\n                let tsContent = \"\";\r\n                try {\r\n                    if (fs.existsSync(tsPath)) {\r\n                        tsContent = fs.readFileSync(tsPath, 'utf-8');\r\n                    }\r\n                } catch (err) {\r\n                    this.warn(`[Excel插件] 读取TS文件失败: ${err}`);\r\n                }\r\n                if (tsContent == \"\") {\r\n                    tsContent = \"declare global {\\n\\n}\\nexport { };\";\r\n                }\r\n                if (this.extractFullInterfaceBlock(tsContent, \"ITable\" + sName)) {\r\n                    //console.log(\"替换接口:\" + sName + \"，内容：\" + tsInterface);\r\n                    tsContent = this.replaceInterfaceBlock(tsContent, \"ITable\" + sName, tsInterface);\r\n                } else {\r\n                    //console.log(\"加到末尾：\" + tsInterface);\r\n                    tsContent = tsContent.replace(/}\\nexport { };$/, tsInterface + \"}\\nexport { };\");\r\n                }\r\n                fs.writeFileSync(tsPath, tsContent, 'utf-8');\r\n            }\r\n        } catch (err) {\r\n            throw new Error(`工作表 \"${sheetName}\" 导出失败 (文件: ${path.basename(filePath)}): ${err}`);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 转义正则特殊字符\r\n     */\r\n    escapeRegExp(str: string): string {\r\n        return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n    }\r\n\r\n    /**\r\n     * 精准查找接口声明行（全字匹配）\r\n     */\r\n    findInterfaceDeclarationLine(fileContent: string, interfaceName: string): {\r\n        lineStart: number;\r\n        lineEnd: number;\r\n        lineContent: string;\r\n    } | null {\r\n        // 使用单词边界 \\b 确保全字匹配\r\n        const regex = new RegExp(\r\n            `\\\\binterface\\\\s+${this.escapeRegExp(interfaceName)}\\\\b(?:\\\\s*<[^>]*>)?\\\\s*[\\\\{\\\\n]`,\r\n            'g'\r\n        );\r\n\r\n        let match;\r\n        while ((match = regex.exec(fileContent)) !== null) {\r\n            // 找到匹配位置，确定完整行\r\n            const matchStart = match.index;\r\n\r\n            // 向前找到行开始\r\n            const lineStart = fileContent.lastIndexOf('\\n', matchStart - 1) + 1;\r\n\r\n            // 向后找到行结束\r\n            const lineEnd = fileContent.indexOf('\\n', matchStart);\r\n            const actualLineEnd = lineEnd === -1 ? fileContent.length : lineEnd;\r\n\r\n            const lineContent = fileContent.substring(lineStart, actualLineEnd);\r\n\r\n            // 验证：确保这一行确实是我们的目标接口\r\n            if (lineContent.trim().startsWith(`interface ${interfaceName}`)) {\r\n                return {\r\n                    lineStart,\r\n                    lineEnd: actualLineEnd,\r\n                    lineContent\r\n                };\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * 提取完整的接口块（包括上方注释）\r\n     */\r\n    extractFullInterfaceBlock(fileContent: string, interfaceName: string): {\r\n        start: number;\r\n        end: number;\r\n        content: string;\r\n    } | null {\r\n        const interfaceLine = this.findInterfaceDeclarationLine(fileContent, interfaceName);\r\n        if (!interfaceLine) {\r\n            return null;\r\n        }\r\n\r\n        // === 向前查找连续的注释块 ===\r\n        let blockStart = interfaceLine.lineStart;\r\n        let currentPos = interfaceLine.lineStart;\r\n\r\n        while (currentPos > 0) {\r\n            const prevLineEnd = currentPos - 1;\r\n            const prevLineStart = fileContent.lastIndexOf('\\n', prevLineEnd - 1) + 1;\r\n            const prevLine = fileContent.substring(prevLineStart, prevLineEnd).trim();\r\n\r\n            // 检查是否为注释行或空行\r\n            if (prevLine === '' ||\r\n                prevLine.startsWith('//') ||\r\n                prevLine.startsWith('/*') ||\r\n                prevLine.startsWith('*')) {\r\n                currentPos = prevLineStart;\r\n            } else {\r\n                blockStart = currentPos;\r\n                break;\r\n            }\r\n        }\r\n\r\n        if (currentPos === 0) {\r\n            blockStart = 0;\r\n        }\r\n\r\n        // === 向后查找接口体结束 ===\r\n        // 找到 interface 行中的开括号位置\r\n        const openBraceIndex = interfaceLine.lineContent.indexOf('{');\r\n        let startPos = interfaceLine.lineStart;\r\n        let braceCount = 0;\r\n\r\n        if (openBraceIndex !== -1) {\r\n            // 开括号在同一行\r\n            startPos = interfaceLine.lineStart + openBraceIndex;\r\n            braceCount = 1;\r\n        } else {\r\n            // 开括号在下一行，找到第一个 {\r\n            const nextOpenBrace = fileContent.indexOf('{', interfaceLine.lineEnd);\r\n            if (nextOpenBrace === -1) return null;\r\n            startPos = nextOpenBrace;\r\n            braceCount = 1;\r\n        }\r\n\r\n        let pos = startPos + 1; // 跳过 {\r\n\r\n        while (pos < fileContent.length && braceCount > 0) {\r\n            if (fileContent[pos] === '{') {\r\n                braceCount++;\r\n            } else if (fileContent[pos] === '}') {\r\n                braceCount--;\r\n            }\r\n            pos++;\r\n        }\r\n\r\n        if (braceCount !== 0) {\r\n            return null; // 括号不匹配\r\n        }\r\n\r\n        const blockEnd = pos;\r\n        const fullContent = fileContent.substring(blockStart, blockEnd);\r\n\r\n        return {\r\n            start: blockStart,\r\n            end: blockEnd,\r\n            content: fullContent\r\n        };\r\n    }\r\n\r\n    /**\r\n     * 完全替换接口块（全字匹配，精准替换）\r\n     */\r\n    replaceInterfaceBlock(\r\n        fileContent: string,\r\n        interfaceName: string,\r\n        newInterfaceBlock: string\r\n    ): string {\r\n        const blockInfo = this.extractFullInterfaceBlock(fileContent, interfaceName);\r\n\r\n        if (!blockInfo) {\r\n            throw new Error(`❌ 接口 \"${interfaceName}\" 未找到！请检查名称是否正确。`);\r\n        }\r\n\r\n        // 验证：确保提取的块确实只包含目标接口\r\n        const interfaceLines = blockInfo.content.split('\\n');\r\n        const interfaceDeclLines = interfaceLines.filter(line =>\r\n            line.trim().startsWith('interface ')\r\n        );\r\n\r\n        if (interfaceDeclLines.length !== 1) {\r\n            throw new Error(`❌ 找到多个 interface 声明，可能匹配错误！`);\r\n        }\r\n\r\n        if (!interfaceDeclLines[0].includes(`interface ${interfaceName}`)) {\r\n            throw new Error(`❌ 匹配到错误的接口名称！`);\r\n        }\r\n\r\n        //console.log(`✅ 精准匹配到接口 \"${interfaceName}\"`);\r\n\r\n        return (\r\n            fileContent.substring(0, blockInfo.start) +\r\n            newInterfaceBlock +\r\n            fileContent.substring(blockInfo.end)\r\n        );\r\n    }\r\n\r\n    // 设置文件监听（终极版）\r\n    setupFileWatcher() {\r\n        this.stopFileWatcher();\r\n\r\n        if (!this.config.excelPath) return;\r\n\r\n        if (!fs.existsSync(this.config.excelPath)) {\r\n            this.error(`[Excel插件] 监听目录不存在: ${this.config.excelPath}`);\r\n            return;\r\n        }\r\n\r\n        try {\r\n            // 使用更可靠的监听方式\r\n            this.fileWatcher = fs.watch(this.config.excelPath, {\r\n                recursive: false,\r\n                encoding: 'utf8'\r\n            }, async (eventType, filename) => {\r\n                if (!filename) return;\r\n                this.loadConfig();\r\n                if (this.config.autoExport == false) return;\r\n\r\n                // 确保是字符串\r\n                const fileNameStr = typeof filename === 'string' ? filename : filename + \"\";\r\n                const ext = path.extname(fileNameStr).toLowerCase();\r\n\r\n                if (ext === '.xlsx' || ext === '.xls') {\r\n                    const filePath = path.join(this.config.excelPath, fileNameStr);\r\n\r\n                    // 额外验证：确保是文件且存在\r\n                    try {\r\n                        if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {\r\n                            this.log(`[Excel插件] 检测到文件变更: ${fileNameStr} (${eventType})`);\r\n\r\n                            // 使用终极重试机制\r\n                            // 重试次数增加到8，基础延迟1秒\r\n                            this.processExcelFileWithRetry(filePath, 8, 1000);\r\n                        }\r\n                    } catch (err) {\r\n                        this.warn(`[Excel插件] 验证文件状态时出错: ${err}`);\r\n                    }\r\n                }\r\n            });\r\n\r\n            // 处理监听错误\r\n            if (this.fileWatcher && typeof this.fileWatcher.on === 'function') {\r\n                this.fileWatcher.on('error', (error: Error) => {\r\n                    this.error(`[Excel插件] 文件监听错误: ${error}`);\r\n\r\n                    // 尝试重新设置监听\r\n                    setTimeout(() => {\r\n                        this.stopFileWatcher();\r\n                        this.setupFileWatcher();\r\n                    }, 15000);\r\n                });\r\n            }\r\n\r\n            this.log('[Excel插件] 已启动Excel目录监听（终极版）');\r\n        } catch (err) {\r\n            this.error(`[Excel插件] 目录监听失败: ${err}`);\r\n\r\n            // 尝试重新设置监听\r\n            setTimeout(() => {\r\n                this.stopFileWatcher();\r\n                this.setupFileWatcher();\r\n            }, 20000);\r\n        }\r\n    }\r\n\r\n    // 带终极重试机制处理Excel文件\r\n    processExcelFileWithRetry(filePath: string, maxRetries: number = 8, baseDelay: number = 1000) {\r\n        let attempt = 0;\r\n        const startTime = Date.now();\r\n\r\n        const tryProcess = () => {\r\n            attempt++;\r\n            const elapsed = Date.now() - startTime;\r\n            const delay = baseDelay * Math.min(1.5 ** (attempt - 1), 4); // 指数退避，但上限为4倍基础延迟\r\n\r\n            this.log(`[Excel插件] 处理文件 \"${path.basename(filePath)}\" - 尝试 ${attempt}/${maxRetries} (延迟 ${Math.round(delay)}ms, 已耗时 ${Math.round(elapsed / 1000)}s)`);\r\n\r\n            setTimeout(() => {\r\n                try {\r\n                    // 额外检查文件是否可读\r\n                    const stats = fs.statSync(filePath);\r\n                    if (stats.size === 0) {\r\n                        throw new Error(\"文件大小为0，可能仍在写入\");\r\n                    }\r\n\r\n                    // 检查文件最后修改时间，确保不是刚被修改\r\n                    const now = Date.now();\r\n                    const fileAge = now - stats.mtimeMs;\r\n                    if (fileAge < 2000) { // 文件修改时间少于2秒，可能还在写入\r\n                        throw new Error(`文件刚被修改 (${Math.round(fileAge)}ms前)，可能仍在写入`);\r\n                    }\r\n\r\n                    this.processExcelFile(filePath);\r\n                    const totalTime = Date.now() - startTime;\r\n                    this.refreshAssetDatabase();\r\n                    this.success(`[Excel插件] 文件 \"${path.basename(filePath)}\" 自动导出成功 (总耗时 ${Math.round(totalTime / 1000)}s, 尝试 ${attempt}/${maxRetries})`);\r\n                } catch (err: any) {\r\n\r\n                    // 详细记录错误\r\n                    this.warn(`[Excel插件] 尝试 ${attempt} 失败: ${err.message || err}`);\r\n\r\n                    // 检查是否是文件锁定或权限错误\r\n                    const isFileLockError = err.message && (\r\n                        err.message.includes('EPERM') ||\r\n                        err.message.includes('EBUSY') ||\r\n                        err.message.includes('permission') ||\r\n                        err.message.includes('locked') ||\r\n                        err.message.includes('EACCES') ||\r\n                        err.message.includes('file size 0') ||\r\n                        err.message.includes('刚被修改')\r\n                    );\r\n\r\n                    if (isFileLockError && attempt < maxRetries) {\r\n                        // 计算下一次尝试的延迟（指数退避）\r\n                        const nextDelay = baseDelay * Math.min(1.5 ** attempt, 4);\r\n                        this.warn(`[Excel插件] 文件 \"${path.basename(filePath)}\" 可能仍在保存中，将在 ${Math.round(nextDelay)}ms 后重试 (尝试 ${attempt + 1}/${maxRetries})`);\r\n                        setTimeout(tryProcess, nextDelay);\r\n                    } else {\r\n                        const totalTime = Date.now() - startTime;\r\n                        this.error(`[Excel插件] 文件 \"${path.basename(filePath)}\" 自动导出失败 (总耗时 ${Math.round(totalTime / 1000)}s): ${err}`);\r\n\r\n                        // 如果是文件锁定错误但已达到最大重试次数，提供具体建议\r\n                        if (isFileLockError) {\r\n                            this.error(`[Excel插件] 建议: 确保Excel完全保存后再进行修改，或增加重试次数和延迟`);\r\n                        }\r\n                    }\r\n                }\r\n            }, delay);\r\n        };\r\n\r\n        // 开始第一次尝试\r\n        tryProcess();\r\n    }\r\n\r\n    // 停止文件监听（更新）\r\n    stopFileWatcher() {\r\n        if (this.fileWatcher) {\r\n            try {\r\n                // 使用类型断言确保调用close方法\r\n                (this.fileWatcher as any).close();\r\n                this.fileWatcher = null;\r\n            } catch (e) {\r\n                this.warn(`[Excel插件] 停止监听时出错: ${e}`);\r\n            }\r\n\r\n            if (this.config.watcher) {\r\n                clearTimeout(this.config.watcher);\r\n                this.config.watcher = null;\r\n            }\r\n            this.log('[Excel插件] 已停止Excel文件监听');\r\n        }\r\n    }\r\n\r\n    // 生成JSON数据\r\n    generateJsonData(dataRows: any[][], headers: any): any[] {\r\n        const result = [];\r\n\r\n        for (const row of dataRows) {\r\n            const obj: any = {};\r\n\r\n            for (let i = 0; i < headers.fields.length; i++) {\r\n                const field = headers.fields[i];\r\n                const type = headers.types[i];\r\n\r\n                if (field) {\r\n                    // 处理空单元格，使用对应类型的默认值\r\n                    const value = row[i] !== undefined ? row[i] : this.getDefaultValue(type);\r\n                    obj[field] = this.convertValue(value, type);\r\n                }\r\n            }\r\n\r\n            result.push(obj);\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    // 根据类型获取默认值\r\n    getDefaultValue(type: string): any {\r\n        if (!type) return null;\r\n\r\n        const cleanType = type.toLowerCase().trim();\r\n        switch (cleanType) {\r\n            case 'int':\r\n            case 'float':\r\n                return 0;\r\n            case 'boolean':\r\n                return false;\r\n            case 'int[]':\r\n            case 'float[]':\r\n            case 'string[]':\r\n            case 'any[]':\r\n                return [];\r\n            case 'string':\r\n                return '';\r\n            default:\r\n                return '';\r\n        }\r\n    }\r\n\r\n\r\n    // 类型转换\r\n    convertValue(value: any, type: string): any {\r\n        if (value === null || value === undefined) return null;\r\n\r\n        const cleanType = type.toLowerCase().trim();\r\n\r\n        try {\r\n            switch (cleanType) {\r\n                case 'int':\r\n                    return parseInt(value);\r\n                case 'float':\r\n                    return parseFloat(value);\r\n                case 'json':\r\n                    return JSON.parse(value);\r\n                case 'boolean':\r\n                    return value.toString().toLowerCase() === 'true' || value === 1;\r\n                case 'int[]':\r\n                    return this.parseArray(value, 'int');\r\n                case 'float[]':\r\n                    return this.parseArray(value, 'float');\r\n                case 'string[]':\r\n                    return this.parseArray(value, 'string');\r\n                case 'any[]':\r\n                    return this.parseArray(value, 'any');\r\n                default:\r\n                    return value;\r\n            }\r\n        } catch (e) {\r\n            this.warn(`[Excel插件] 类型转换失败 [${type}]: ${value} - ${e}`);\r\n            return value;\r\n        }\r\n    }\r\n\r\n    // 解析数组\r\n    parseArray(value: any, targetType: string): any[] {\r\n        if (Array.isArray(value)) return value;\r\n\r\n        // 尝试分割字符串\r\n        let items = [];\r\n        if (typeof value === 'string') {\r\n            items = value.split(/[,;#\\s]\\s*/).filter(v => v);\r\n        } else {\r\n            items = [value];\r\n        }\r\n\r\n        return items.map(item => {\r\n            if (targetType === 'any') {\r\n                // 自动识别类型\r\n                if (!isNaN(item)) {\r\n                    return !isNaN(parseFloat(item)) ? parseFloat(item) : parseInt(item);\r\n                }\r\n                if (item.toLowerCase() === 'true' || item.toLowerCase() === 'false') {\r\n                    return item.toLowerCase() === 'true';\r\n                }\r\n                return item;\r\n            }\r\n\r\n            // 指定类型转换\r\n            switch (targetType) {\r\n                case 'int': return parseInt(item);\r\n                case 'float': return parseFloat(item);\r\n                case 'string': return String(item);\r\n                default: return item;\r\n            }\r\n        });\r\n    }\r\n\r\n    generateTSInterfaceStart(sheetName: string): string {\r\n        const interfaceName = `ITable${sheetName}`;\r\n        const safeSheetName = `${this.makeSafeFileName(sheetName)}`;\r\n\r\n        let tsContent = `    /**\\n     * ${safeSheetName} 配置数据\\n    */\\n`;\r\n        tsContent += `    interface ${interfaceName} {\\n`;\r\n        return tsContent;\r\n    }\r\n\r\n    // 生成TS接口\r\n    generateTSInterface(sheetName: string, headers: any): string {\r\n        const interfaceName = `ITable${sheetName}`;\r\n        const safeSheetName = `${this.makeSafeFileName(sheetName)}`;\r\n\r\n        let tsContent = `    /**\\n     * ${safeSheetName} 配置数据\\n    */\\n`;\r\n        tsContent += `    interface ${interfaceName} {\\n`;\r\n\r\n        for (let i = 0; i < headers.fields.length; i++) {\r\n            const field = headers.fields[i];\r\n            const type = headers.types[i];\r\n            const description = headers.descriptions[i] || '字段说明';\r\n\r\n            if (field) {\r\n                tsContent += `        /** ${description} */\\n`;\r\n                tsContent += `        readonly ${field}: ${this.convertToTSType(type)};\\n`;\r\n            }\r\n        }\r\n\r\n        tsContent += `    }\\n`;\r\n        return tsContent;\r\n    }\r\n\r\n    // 转换为TS类型\r\n    convertToTSType(excelType: string): string {\r\n        if (!excelType) return 'any';\r\n\r\n        const type = excelType.toLowerCase().trim();\r\n        switch (type) {\r\n            case 'string':\r\n                return 'string';\r\n            case 'int':\r\n            case 'float':\r\n                return 'number';\r\n            case 'boolean':\r\n                return 'boolean';\r\n            case 'int[]':\r\n                return 'number[]';\r\n            case 'float[]':\r\n                return 'number[]';\r\n            case 'string[]':\r\n                return 'string[]';\r\n            case 'any[]':\r\n                return '(number | string | boolean)[]';\r\n            default:\r\n                return 'any';\r\n        }\r\n    }\r\n\r\n    // 转换为PascalCase\r\n    toPascalCase(str: string): string {\r\n        return str.replace(/(\\w)(\\w*)/g, (_, g1, g2) =>\r\n            g1.toUpperCase() + g2.toLowerCase()\r\n        ).replace(/[^a-zA-Z0-9]/g, '');\r\n    }\r\n\r\n    // 创建安全的文件名\r\n    makeSafeFileName(name: string): string {\r\n        return name.replace(/[^a-zA-Z0-9_]/g, '_');\r\n    }\r\n\r\n    // 日志输出\r\n    log(message: string) {\r\n        console.log(message);\r\n    }\r\n\r\n    error(message: string) {\r\n        console.error(message);\r\n    }\r\n\r\n    warn(message: string) {\r\n        console.warn(message);\r\n    }\r\n\r\n    success(message: string) {\r\n        console.log(message);\r\n    }\r\n\r\n    // 消息处理\r\n    messages = {\r\n        'excel-to-json-ts:export-manual': () => {\r\n            this.exportManual();\r\n        }\r\n    }\r\n\r\n    // 刷新资源管理器\r\n    async refreshAssetDatabase() {\r\n        try {\r\n            // 确保路径是项目内的路径（db://assets/开头）\r\n            const jsonDbPath = this.convertToDbPath(this.config.jsonExportPath);\r\n            const tsDbPath = this.convertToDbPath(this.config.tsExportPath);\r\n\r\n            // 刷新JSON导出目录\r\n            if (jsonDbPath && jsonDbPath.startsWith('db://')) {\r\n                await Editor.Message.request('asset-db', 'refresh-asset', jsonDbPath);\r\n            }\r\n\r\n            // 刷新TS导出目录\r\n            if (tsDbPath && tsDbPath.startsWith('db://')) {\r\n                await Editor.Message.request('asset-db', 'refresh-asset', tsDbPath);\r\n            }\r\n\r\n            this.success('[Excel插件] 资源刷新请求已发送');\r\n        } catch (err) {\r\n            this.error(`[Excel插件] 资源刷新失败: ${err}`);\r\n        }\r\n    }\r\n\r\n    // 将系统路径转换为Cocos的db路径\r\n    convertToDbPath(systemPath: string): string {\r\n        if (!systemPath) return '';\r\n\r\n        try {\r\n            // 获取项目路径\r\n            const projectPath = Editor.Project.path;\r\n\r\n            // 规范化路径（统一使用正斜杠）\r\n            systemPath = systemPath.replace(/\\\\/g, '/');\r\n            const normalizedProjectPath = projectPath.replace(/\\\\/g, '/');\r\n\r\n            // 确保路径以/结尾\r\n            const projectPathWithSlash = normalizedProjectPath.endsWith('/')\r\n                ? normalizedProjectPath\r\n                : normalizedProjectPath + '/';\r\n\r\n            // 检查是否在项目目录内\r\n            if (systemPath.startsWith(projectPathWithSlash)) {\r\n                // 计算相对路径\r\n                const relativePath = systemPath.substring(projectPathWithSlash.length);\r\n                return `db://${relativePath}`;\r\n            }\r\n\r\n            // 如果路径包含assets目录，尝试直接转换\r\n            if (systemPath.includes('/assets/') || systemPath.includes('\\\\assets\\\\')) {\r\n                const assetsIndex = systemPath.toLowerCase().indexOf('/assets/');\r\n                if (assetsIndex !== -1) {\r\n                    const relativeToAssets = systemPath.substring(assetsIndex + 1);\r\n                    return `db://${relativeToAssets}`;\r\n                }\r\n            }\r\n\r\n            this.warn(`[Excel插件] 路径不在项目内，可能无法正确刷新: ${systemPath}`);\r\n            return systemPath;\r\n        } catch (err) {\r\n            this.error(`[Excel插件] 路径转换失败: ${err}`);\r\n            return systemPath;\r\n        }\r\n    }\r\n}\r\n\r\nexport const excelToJsonPlugin = new ExcelToJsonPlugin();"]}