fast-cocos 1.0.0

package/dist/xlsx/src/XlsxParser.js

@@ -0,0 +1,580 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const node_xlsx_1 = __importDefault(require("node-xlsx"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 工作表类型
+ */
+var SheetType;
+(function (SheetType) {
+    SheetType["Map"] = "Map";
+    SheetType["Array"] = "Array";
+    SheetType["KVMap"] = "KVMap";
+    SheetType["VMap"] = "VMap";
+})(SheetType || (SheetType = {}));
+/**
+ * Xlsx解析器
+ */
+class XlsxParser {
+    constructor(options) {
+        /** 数组分隔符类 */
+        this.separators = ["|", ";", ",", "-", "_"];
+        /** 接口声明表 接口名称 => 字段声明 */
+        this.declareMap = new Map();
+        this.options = options;
+        // 数组分隔符类型
+        if (this.options.separators) {
+            this.separators = this.options.separators || this.separators;
+        }
+        // 移除临时目录
+        if (fs_1.default.existsSync(this.options.tmpDir)) {
+            fs_1.default.rmSync(this.options.tmpDir, { recursive: true });
+        }
+    }
+    /**
+     * 解析xlsx文件
+     */
+    parse() {
+        const xlsxFiles = this.findFilesWithExtensions(this.options.xlsxDir, [".xlsx", ".xls"]);
+        xlsxFiles.forEach((filePath) => {
+            console.info("\x1b[35m%s\x1b[0m", "解析文件: " + filePath);
+            const xlsxName = path_1.default.basename(filePath, path_1.default.extname(filePath));
+            const workSheetsFromFile = node_xlsx_1.default.parse(filePath);
+            workSheetsFromFile.forEach((workSheet) => {
+                this.parseWorkSheet(xlsxName, workSheet);
+            });
+        });
+        this.writeTs();
+        this.mergeJson();
+    }
+    /**
+     * 解析出表信息
+     * @param xlsxName xlsx文件名
+     * @param workSheet 工作表
+     */
+    parseWorkSheet(xlsxName, workSheet) {
+        let { name, data } = workSheet;
+        name = this.processString(name);
+        const arr = name.split(".");
+        // 解析表名、类型、版本
+        const [basename, sheetType, version] = arr;
+        // 去除空数组
+        data = data.filter((item) => item.length > 0);
+        /** 介绍（第一行） */
+        let intros = data[0];
+        /** 类型（第二行） */
+        let types = data[1];
+        /** 字段（第三行） */
+        let fields = data[2];
+        // VMap类型特殊处理
+        if (SheetType.VMap == sheetType) {
+            intros = [];
+            types = [];
+            fields = [];
+            data.shift();
+        }
+        else {
+            data.shift();
+            data.shift();
+            data.shift();
+        }
+        data.forEach((row) => row.forEach((v, i) => (row[i] = String(v || "").trim())));
+        let fileName = `${basename}${sheetType}`;
+        let typeName = fileName;
+        // 带版本号
+        if (version === null || version === void 0 ? void 0 : version.startsWith("v")) {
+            fileName = `${typeName}.${arr[2]}`;
+        }
+        const outPath = path_1.default.join(this.options.tmpDir, xlsxName, `${fileName}.json`);
+        // 工作表信息
+        const sheetInfo = {
+            sheetType: sheetType,
+            xlsxName,
+            basename,
+            outPath,
+            typeName,
+            intros,
+            types,
+            fields,
+            data
+        };
+        console.info("\x1b[36m%s\x1b[0m", "解析表: " + name);
+        switch (sheetType) {
+            case SheetType.Map:
+                this.parseMap(sheetInfo);
+                break;
+            case SheetType.Array:
+                this.parseArray(sheetInfo);
+                break;
+            case SheetType.KVMap:
+                this.parseKVMap(sheetInfo);
+                break;
+            case SheetType.VMap:
+                this.parseVMap(sheetInfo);
+                break;
+            default:
+                console.error(`表【${sheetType}】格式错误，导出失败`);
+                break;
+        }
+    }
+    /**
+     * 解析对象
+     * @param sheetInfo 工作表信息
+     */
+    parseMap(sheetInfo) {
+        const { types, fields, data } = sheetInfo;
+        // 类型声明
+        this.parseTypeDeclare(sheetInfo);
+        // 解析内容
+        const content = {};
+        for (const row of data) {
+            const rowInfo = {};
+            for (let i = 0; i < row.length; ++i) {
+                const field = fields[i];
+                if (field) {
+                    const columns = data.map((v) => v[i]);
+                    rowInfo[field] = this.parseValue(types[i], row[i], columns);
+                }
+            }
+            // 只有有效行才会记录
+            if (Object.keys(rowInfo).length) {
+                const key = rowInfo.id || rowInfo[fields[0]];
+                content[key] = rowInfo;
+            }
+        }
+        // 写json文件
+        this.writeSheetSync(sheetInfo.outPath, content);
+    }
+    /**
+     * 解析数组
+     * @param sheetInfo 工作表信息
+     */
+    parseArray(sheetInfo) {
+        const { types, fields, data } = sheetInfo;
+        // 类型声明
+        this.parseTypeDeclare(sheetInfo);
+        // 解析内容
+        const content = [];
+        for (let i = 0; i < data.length; ++i) {
+            const info = {};
+            const col = data[i];
+            for (let j = 0; j < col.length; ++j) {
+                const field = fields[j];
+                if (field) {
+                    const columns = data.map((v) => v[j]);
+                    info[field] = this.parseValue(types[j], col[j], columns);
+                }
+            }
+            if (Object.keys(info).length) {
+                content.push(info);
+            }
+        }
+        // 写json文件
+        this.writeSheetSync(sheetInfo.outPath, content);
+    }
+    /**
+     * 解析键值表
+     * @param sheetInfo 工作表信息
+     */
+    parseKVMap(sheetInfo) {
+        const { types, data } = sheetInfo;
+        // 类型声明
+        this.parseTypeDeclare(sheetInfo);
+        // 解析内容
+        const content = {};
+        const [, type] = types;
+        for (let i = 0; i < data.length; ++i) {
+            const [field, value] = data[i];
+            if (field) {
+                content[field] = this.parseValue(type, value, [value]);
+            }
+        }
+        // 写json文件
+        this.writeSheetSync(sheetInfo.outPath, content);
+    }
+    /**
+     * 解析键值表
+     * @param sheetInfo 工作表信息
+     */
+    parseVMap(sheetInfo) {
+        const { data } = sheetInfo;
+        // 声明内容
+        this.parseTypeDeclare(sheetInfo);
+        // 表内容
+        const content = {};
+        for (let i = 0; i < data.length; ++i) {
+            const [field, type, value] = data[i];
+            if (field) {
+                content[field] = this.parseValue(type, value, [value]);
+            }
+        }
+        // 写json文件
+        this.writeSheetSync(sheetInfo.outPath, content);
+    }
+    /**
+     * 解析值
+     * @param type 值类型
+     * @param value 值
+     * @param columns 列数据
+     */
+    parseValue(type, value, columns) {
+        // 将值转换为字符串
+        const valueStr = String(value || "");
+        // 数组类型
+        const { baseType, separators } = this.splitTypeWithSeparators(type);
+        if (separators.length > 0) {
+            return this.toArray(baseType, separators, valueStr, columns);
+        }
+        // 基础类型
+        switch (type) {
+            case "int":
+                return parseInt(valueStr || "0");
+            case "float":
+                return parseFloat(valueStr || "0");
+            case "boolean":
+                return Boolean(valueStr || "0");
+            case "number":
+                return Number(valueStr || "0");
+            case "string":
+                if (valueStr) {
+                    return valueStr.trim();
+                }
+                return undefined;
+            case "{}":
+                return JSON.parse(valueStr);
+            default:
+                console.log("未处理类型", type);
+                return valueStr;
+        }
+    }
+    /**
+     * 拆分类型字符串为基本类型和分隔符数组
+     * @param typeString 输入的类型字符串，如 "int[;][|]"
+     * @returns 包含基本类型和分隔符数组的对象
+     */
+    splitTypeWithSeparators(typeString) {
+        // 1. 使用正则表达式匹配基本类型和所有分隔符部分
+        const match = typeString.match(/^([^\[]+)((?:\[([^\]]*)\])*)$/);
+        if (!match) {
+            throw new Error(`Invalid type string: ${typeString}`);
+        }
+        const baseType = match[1];
+        const dimensionsPart = match[2];
+        // 2. 提取所有分隔符
+        const separators = [];
+        const separatorRegex = /\[([^\]]*)\]/g;
+        let separatorMatch;
+        while ((separatorMatch = separatorRegex.exec(dimensionsPart)) !== null) {
+            separators.push(separatorMatch[1]);
+        }
+        return {
+            baseType,
+            separators
+        };
+    }
+    /**
+     * 字符串转数组
+     * @param baseType 基础类型
+     * @param separators 分隔符
+     * @param valueStr 值
+     * @param columns 列数据，用于抽取数组分隔符
+     */
+    toArray(baseType, separators, valueStr, columns) {
+        if (!valueStr) {
+            return undefined;
+        }
+        // 分隔符数量
+        let separatorCount = separators.length;
+        // 逆序分隔符
+        let realSeparators = separators.filter((item) => item !== "").reverse();
+        // 从列中抽取分隔符
+        if (realSeparators.length <= 0 && separatorCount > 0) {
+            outer: for (let column of columns) {
+                if (!column) {
+                    continue;
+                }
+                const columnSeparators = [];
+                // 遍历每个字符
+                for (const char of column) {
+                    if (this.separators.includes(char) && !columnSeparators.includes(char)) {
+                        columnSeparators.push(char);
+                        if (columnSeparators.length == separatorCount) {
+                            realSeparators = columnSeparators.reverse();
+                            break outer;
+                        }
+                    }
+                }
+            }
+            // 兜底分隔符
+            if (realSeparators.length <= 0) {
+                realSeparators = Array.from({ length: separatorCount }).fill("?");
+            }
+        }
+        return this.splitStringToNestedArray(baseType, valueStr, realSeparators);
+    }
+    /**
+     * 将字符串按多级分隔符拆分为类型安全的嵌套数组
+     * @param baseType 基础类型
+     * @param valueStr 输入字符串
+     * @param delimiters 分隔符数组，决定嵌套层级和每层的分隔方式
+     * @returns 嵌套数组，深度与分隔符数组长度相同，完全类型安全
+     */
+    splitStringToNestedArray(baseType, valueStr, delimiters) {
+        // 递归终止条件：没有更多分隔符时返回字符串本身
+        if (delimiters.length === 0) {
+            return this.parseValue(baseType, valueStr, []);
+        }
+        const [currentDelimiter, ...remainingDelimiters] = delimiters;
+        // 如果当前层级不包含分隔符，直接进入下一层级
+        if (!valueStr.includes(currentDelimiter)) {
+            return [this.splitStringToNestedArray(baseType, valueStr, remainingDelimiters)];
+        }
+        // 分割当前层级并递归处理每个部分
+        return valueStr.split(currentDelimiter).map((part) => this.splitStringToNestedArray(baseType, part, remainingDelimiters));
+    }
+    /**
+     * 遍历目录获得指定扩展名的文件
+     * @param dir 目录
+     * @param exts 扩展名
+     * @param files 文件列表
+     */
+    findFilesWithExtensions(dir, extensions, files = []) {
+        dir = dir.trim();
+        if (!Array.isArray(extensions)) {
+            extensions = [extensions];
+        }
+        const fileList = fs_1.default.readdirSync(dir);
+        fileList.forEach((file) => {
+            const filePath = path_1.default.join(dir, file);
+            const fileStat = fs_1.default.statSync(filePath);
+            if (fileStat.isFile() && this.endsWithAny(file, extensions)) {
+                files.push(filePath);
+            }
+            else if (fileStat.isDirectory()) {
+                this.findFilesWithExtensions(filePath, extensions, files);
+            }
+        });
+        return files;
+    }
+    /**
+     * 判断一个字符串是否以一个数组中任意一个字符串结尾
+     * @param str 字符串
+     * @param suffixes 后缀数组
+     */
+    endsWithAny(str, suffixes) {
+        for (const suffix of suffixes) {
+            if (str.endsWith(suffix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 向数组中添加元素
+     * @param arr 数组
+     * @param item 元素
+     * @param spaces 空格数
+     */
+    pushUnique(arr, item, spaces = 4) {
+        let str = " ".repeat(spaces) + item;
+        if (!arr.includes(str)) {
+            arr.push(str);
+        }
+    }
+    /**
+     * 类型声明
+     * @param sheetInfo 工作表信息
+     */
+    parseTypeDeclare(sheetInfo) {
+        const { intros, types, fields, xlsxName, basename, sheetType, typeName, data } = sheetInfo;
+        const lines = [];
+        switch (sheetType) {
+            case SheetType.VMap: {
+                this.pushUnique(lines, `/** ${xlsxName} */`, 0);
+                this.pushUnique(lines, `interface ${typeName} {`, 0);
+                for (let i = 0; i < data.length; ++i) {
+                    let [field, type, , comment] = data[i];
+                    if (field) {
+                        type = this.removeExtraType(type);
+                        this.pushUnique(lines, `/** ${comment} */`);
+                        this.pushUnique(lines, `readonly ${field}: ${type};`);
+                    }
+                }
+                this.pushUnique(lines, `}`, 0);
+                this.declareMap.set(typeName, lines);
+                break;
+            }
+            case SheetType.KVMap: {
+                let [key, type] = types;
+                type = this.removeExtraType(type);
+                this.pushUnique(lines, `/** 键: ${intros[0]} 值: ${type} */`);
+                this.pushUnique(lines, `type ${typeName} = Map<${key}, ${type}>;`);
+                this.declareMap.set(typeName, lines);
+                break;
+            }
+            case SheetType.Map: {
+                this.pushUnique(lines, `interface ${basename} {`, 0);
+                for (let i = 0; i < intros.length; ++i) {
+                    const field = fields[i];
+                    if (field) {
+                        const type = this.removeExtraType(types[i]);
+                        this.pushUnique(lines, `/** ${intros[i]} */`, 4);
+                        this.pushUnique(lines, `readonly ${field}: ${type};`, 4);
+                    }
+                }
+                this.pushUnique(lines, `}\n`, 0);
+                this.pushUnique(lines, `/** ${xlsxName} */`, 0);
+                this.pushUnique(lines, `type ${typeName} = Map<${types[0]}, ${basename}>;`, 0);
+                this.declareMap.set(typeName, lines);
+                break;
+            }
+            case SheetType.Array: {
+                this.pushUnique(lines, `/** ${xlsxName}行数据 */`, 0);
+                this.pushUnique(lines, `interface ${basename} {`, 0);
+                for (let i = 0; i < intros.length; ++i) {
+                    const intro = intros[i];
+                    const type = this.removeExtraType(types[i]);
+                    const field = fields[i];
+                    if (field) {
+                        this.pushUnique(lines, `/** ${intro} */`);
+                        this.pushUnique(lines, `readonly ${field}: ${type};`);
+                    }
+                }
+                this.pushUnique(lines, `}\n`, 0);
+                this.pushUnique(lines, `/** ${xlsxName} */`, 0);
+                this.pushUnique(lines, `type ${typeName} = ${basename}[];`, 0);
+                this.declareMap.set(typeName, lines);
+                break;
+            }
+            default:
+                console.warn("未处理声明类型", sheetType);
+                break;
+        }
+    }
+    /**
+     * 去除多余类型字符
+     * @param str
+     */
+    removeExtraType(str) {
+        // 使用正则表达式匹配所有方括号中的内容
+        const pattern = /\[(.*?)\]/g;
+        let match;
+        let result = "";
+        let lastIndex = 0;
+        // 循环匹配方括号中的内容
+        while ((match = pattern.exec(str)) !== null) {
+            // 将方括号中的内容替换为中括号对
+            result += str.slice(lastIndex, match.index) + "[]";
+            lastIndex = pattern.lastIndex;
+        }
+        // 添加剩余的字符串部分
+        result += str.slice(lastIndex);
+        // 如果没有匹配到方括号中的内容，则返回原始字符串
+        return result;
+    }
+    /**
+     * 处理字符串，确保它不以数字开头，并且移除所有空格、制表符和换行符
+     * @param input
+     */
+    processString(input) {
+        // Remove leading digits
+        let processedStr = input.replace(/^\d+/, "");
+        // Remove whitespace, tabs, and newlines
+        processedStr = processedStr.replace(/[\s\t\n]/g, "");
+        return processedStr;
+    }
+    /**
+     * 合并JSON文件
+     */
+    mergeJson() {
+        const jsonDir = path_1.default.join(this.options.tmpDir);
+        const files = this.findFilesWithExtensions(jsonDir, [".json"]);
+        const json = {};
+        files.forEach((filePath) => {
+            const basename = path_1.default.basename(filePath);
+            const arr = this.processString(basename).split(".");
+            let sheetName = arr[0];
+            if (arr.length == 3) {
+                sheetName += `.${arr[1]}`;
+            }
+            json[sheetName] = require(filePath);
+        });
+        this.writeFileSync(this.options["xlsx.json"], json);
+    }
+    /**
+     * 写json文件到本地
+     * @param filePath 文件路径
+     * @param data 数据
+     */
+    writeSheetSync(filePath, data) {
+        const content = JSON.stringify(data, null, 4);
+        filePath = path_1.default.resolve(filePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, content, { encoding: "utf-8" });
+        console.info("\x1b[32m%s\x1b[0m", "写文件: " + filePath);
+    }
+    /**
+     * 写文件
+     * @param filePath 文件路径
+     * @param content 文件内容
+     */
+    writeFileSync(filePath, content) {
+        if (typeof content != "string") {
+            content = JSON.stringify(content, null, 4);
+        }
+        console.info("\x1b[32m%s\x1b[0m", "写文件: " + filePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, content, { encoding: "utf-8" });
+    }
+    /**
+     * 写ts文件到本地
+     */
+    writeTs() {
+        // xlsx.sheet.d.ts
+        let declareStr = `declare namespace sheet {`;
+        declareStr += `\n    /** 整数 */`;
+        declareStr += `\n    type int = number;`;
+        // 遍历声明表
+        this.declareMap.forEach((value) => {
+            if (value.length <= 0) {
+                return;
+            }
+            value = value.map((v) => " ".repeat(4) + v);
+            declareStr += "\n\n";
+            declareStr += value.join("\n");
+        });
+        declareStr += `\n}\n`;
+        this.writeFileSync(this.options["xlsx.sheet.d.ts"], declareStr);
+        // xlsx.ts
+        const jsonDir = path_1.default.join(this.options.tmpDir);
+        const templatePath = path_1.default.join(this.options.execDir, "template", "xlsx.txt");
+        let scriptStr = fs_1.default.readFileSync(templatePath, "utf8");
+        // 属性声明
+        let propertyStr = " ".repeat(4) + `public readonly version: XlsxVersion = "v1";\n`;
+        // 赋值声明
+        let assignStr = "";
+        const files = this.findFilesWithExtensions(jsonDir, [".json"]);
+        for (let i = 0; i < files.length; ++i) {
+            const filePath = files[i];
+            const basename = this.processString(path_1.default.basename(filePath));
+            const annotation = path_1.default.basename(path_1.default.dirname(filePath));
+            const arr = basename.split(".");
+            const [filename] = arr;
+            if (arr.length == 3) {
+                continue;
+            }
+            propertyStr += `\n`;
+            propertyStr += " ".repeat(4) + `/** ${annotation} */\n`;
+            propertyStr += " ".repeat(4) + `public readonly ${filename}: sheet.${filename};\n`;
+            assignStr += " ".repeat(8) + `(this.${filename} as any) = "${filename}";\n`;
+        }
+        scriptStr = scriptStr.replace("{0}", propertyStr);
+        scriptStr = scriptStr.replace("{1}", assignStr);
+        this.writeFileSync(this.options["xlsx.ts"], scriptStr);
+    }
+}
+exports.default = XlsxParser;

package/dist/xlsx/src/define.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/xlsx/src/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("../../logger"));
+const XlsxParser_1 = __importDefault(require("./XlsxParser"));
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        commander_1.program
+            .name("xlsx")
+            .description("xlsx config table parser")
+            .version("1.0.0")
+            .requiredOption("-s, --source <path>", "source directory")
+            .requiredOption("-o, --output <path>", "output directory")
+            .requiredOption("--script <directory>", "script file directory")
+            .parse(process.argv);
+        const options = commander_1.program.opts();
+        let execDir = path_1.default.dirname(__dirname);
+        const scriptPath = path_1.default.resolve(__filename);
+        if (/\/snapshot\//.test(scriptPath)) {
+            execDir = path_1.default.dirname(process.execPath);
+        }
+        logger_1.default.info(`执行目录: ${execDir}`);
+        const xlsxParser = new XlsxParser_1.default({
+            execDir,
+            tmpDir: path_1.default.join(options.source, "json"),
+            xlsxDir: options.source,
+            "xlsx.ts": path_1.default.join(options.script, "xlsx.ts"),
+            "xlsx.sheet.d.ts": path_1.default.join(options.script, "xlsx.sheet.d.ts"),
+            "xlsx.json": path_1.default.join(options.output, "xlsx.json")
+        });
+        xlsxParser.parse();
+    });
+}
+void main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});