config2ts 2.3.3 → 2.4.0

package/lib/config2ts.d.ts

@@ -1,9 +1,7 @@
-export declare const Convert: {
-    ini: (str: any, moduleName: any) => string;
-    csv: (str: any, moduleName: any) => string;
-    toml: (str: any, moduleName: any) => string;
-};
-export declare function GetTsString(filePath: any): any;
-export declare function GetTsStringFromFileList(fileList: any): any;
-export declare function GetValidFileList(fileList: any): any;
-export declare function startConvert(dir: string, outDir: string, merge: string | null): void;
+type ConvertHandler = (str: string, moduleName: string) => string;
+export declare const Convert: Record<string, ConvertHandler>;
+export declare function GetTsString(filePath: string): string;
+export declare function GetTsStringFromFileList(fileList: string[]): string;
+export declare function GetValidFileList(fileList: string[]): string[];
+export declare function startConvert(dir: string, outDir: string, merge: string): void;
+export {};

package/lib/config2ts.js

@@ -1,65 +1,134 @@
 "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.Convert = void 0;
 exports.GetTsString = GetTsString;
 exports.GetTsStringFromFileList = GetTsStringFromFileList;
 exports.GetValidFileList = GetValidFileList;
 exports.startConvert = startConvert;
-var path = require("path");
-var fs = require("fs");
-var d3_dsv_1 = require("d3-dsv");
-var json5 = require("json5");
-var changeCase = require("change-case");
-var toml = require("toml");
-var EnumStr = 'Enum';
-var EnumIndexStr = 'EnumIndex';
-var EnumArrayString = 'Enum[]';
-var IndexStr = 'Index';
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const d3_dsv_1 = require("d3-dsv");
+const json5 = __importStar(require("json5"));
+const changeCase = __importStar(require("change-case"));
+const toml = __importStar(require("toml"));
+const EnumStr = "Enum";
+const EnumIndexStr = "EnumIndex";
+const EnumArrayString = "Enum[]";
+const IndexStr = "Index";
+const ObjectStr = "Object";
+const RefPrefix = "Ref[";
+const RefSuffix = "]";
+const RefEnumPrefix = "RefEnum[";
+const RefEnumArraySuffix = "][]";
 exports.Convert = {
     ini: function (str, moduleName) {
-        var obj = toml.parse(str);
-        return "export const ".concat(moduleName, " = ").concat(json5.stringify(obj, null, 4), ";");
+        const obj = toml.parse(str);
+        return `export const ${moduleName} = ${json5.stringify(obj, null, 4)};`;
     },
     csv: function (str, moduleName) {
         return csv2ts(str, moduleName);
     },
     toml: function (str, moduleName) {
-        var obj = toml.parse(str);
-        return "export const ".concat(moduleName, " = ").concat(json5.stringify(obj, null, 4), ";");
-    }
+        const obj = toml.parse(str);
+        return `export const ${moduleName} = ${json5.stringify(obj, null, 4)};`;
+    },
 };
 function csv2ts(csvString, moduleName) {
-    var convert = {};
-    var result = (0, d3_dsv_1.csvParse)(csvString, function (d, i) {
+    let convert = {};
+    const refFields = [];
+    const refEnumFields = [];
+    const result = (0, d3_dsv_1.csvParse)(csvString, function (d, i) {
         if (i === 0) {
             convert = d;
+            for (const k in convert) {
+                if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
+                    refFields.push(k);
+                }
+                if (parseRefEnum(convert[k])) {
+                    refEnumFields.push(k);
+                }
+            }
             return null;
         }
         else {
-            for (var k in d) {
-                // console.log(`convert[k]: ${convert[k]}, d[k]: ${d[k]}, k: ${k}`)
-                if (global[convert[k]] instanceof Function) {
+            for (const k in d) {
+                if (convert[k] === ObjectStr) {
+                    d[k] = parseObject(d[k]);
+                }
+                else if (typeof global[convert[k]] === "function") {
                     d[k] = global[convert[k]](d[k]);
                 }
-                else if (convert[k] === 'String[]') {
-                    if (d[k] === '') {
-                        // Enum array do not include empty string
+                else if (convert[k] === "String[]") {
+                    if (d[k] === "") {
                         d[k] = [];
                     }
                     else {
-                        d[k] = d[k].trim().split(',').map(function (v) { return v.trim(); });
+                        d[k] = d[k].trim().split(",").map((v) => v.trim());
                     }
                 }
-                else if (convert[k] === 'Number[]') {
-                    d[k] = d[k].trim().split(',').map(function (val) { return Number(val); });
+                else if (convert[k] === "Number[]") {
+                    d[k] = d[k].trim().split(",").map((val) => Number(val));
                 }
-                else if (convert[k] === 'Enum[]') {
-                    if (d[k] === '') {
-                        // Enum array do not include empty string
+                else if (convert[k] === "Enum[]") {
+                    if (d[k] === "") {
                         d[k] = [];
                     }
                     else {
-                        d[k] = d[k].trim().split(',').map(function (v) { return v.trim(); });
+                        d[k] = d[k].trim().split(",").map((v) => v.trim());
+                    }
+                }
+                else if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
+                    if (d[k] === "") {
+                        console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" ref value is empty`);
+                    }
+                }
+                else if (parseRefEnum(convert[k])) {
+                    const refEnum = parseRefEnum(convert[k]);
+                    if (refEnum.isArray) {
+                        if (d[k] === "") {
+                            d[k] = [];
+                        }
+                        else {
+                            d[k] = d[k].trim().split(",").map((v) => v.trim());
+                        }
+                    }
+                    else {
+                        if (d[k] === "") {
+                            console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" ref enum value is empty`);
+                        }
                     }
                 }
                 else {
@@ -69,54 +138,62 @@ function csv2ts(csvString, moduleName) {
             return d;
         }
     });
-    // 删除columns属性
     delete result.columns;
     if (result.length <= 0) {
         return "";
     }
-    var template = "export namespace ".concat(moduleName, " {\n\n");
-    // generate enum type
-    for (var field in convert) {
+    let template = `export namespace ${moduleName} {\n\n`;
+    for (const field in convert) {
         if (convert[field] == EnumStr || convert[field] == EnumIndexStr) {
-            var enumValues = [];
-            for (var _i = 0, result_1 = result; _i < result_1.length; _i++) {
-                var row = result_1[_i];
-                var enumValue = row[field];
+            const enumValues = [];
+            for (const row of result) {
+                const enumValue = row[field];
                 if (!enumValues.includes(enumValue)) {
                     enumValues.push(enumValue);
                 }
             }
-            enumValues = enumValues.map(function (value) { return "\"".concat(value, "\""); });
-            template += "    export type ".concat(field, " = ").concat(enumValues.join(' | '), ";\n");
-            // general enum list for length test
-            template += "    export const ".concat(field, "List: ").concat(field, "[] = [").concat(enumValues.join(', '), "];\n\n");
+            const enumValueStrings = enumValues.map((value) => `"${value}"`);
+            template += `    export type ${field} = ${enumValueStrings.join(" | ")};\n`;
+            template += `    export const ${field}List: ${field}[] = [${enumValueStrings.join(", ")}];\n\n`;
         }
         else if (convert[field] == EnumArrayString) {
-            var enumValues = [];
-            for (var _a = 0, result_2 = result; _a < result_2.length; _a++) {
-                var row = result_2[_a];
-                var enumArrayValue = row[field];
-                for (var _b = 0, enumArrayValue_1 = enumArrayValue; _b < enumArrayValue_1.length; _b++) {
-                    var enumValue = enumArrayValue_1[_b];
+            const enumValues = [];
+            for (const row of result) {
+                const enumArrayValue = row[field];
+                for (const enumValue of enumArrayValue) {
                     if (!enumValues.includes(enumValue)) {
                         enumValues.push(enumValue);
                     }
                 }
             }
-            enumValues = enumValues.map(function (value) { return "\"".concat(value, "\""); });
-            template += "    export type ".concat(field, " = ").concat(enumValues.join(' | '), ";\n");
-            // general enum list for length test
-            template += "    export const ".concat(field, "List: ").concat(field, "[] = [").concat(enumValues.join(', '), "];\n\n");
+            const enumValueStrings = enumValues.map((value) => `"${value}"`);
+            template += `    export type ${field} = ${enumValueStrings.join(" | ")};\n`;
+            template += `    export const ${field}List: ${field}[] = [${enumValueStrings.join(", ")}];\n\n`;
+        }
+        else if (convert[field] == ObjectStr) {
+            const keyTypes = {};
+            for (const row of result) {
+                const objValue = row[field];
+                for (const key in objValue) {
+                    if (!keyTypes[key]) {
+                        keyTypes[key] = new Set();
+                    }
+                    keyTypes[key].add(getTypeName(objValue[key]));
+                }
+            }
+            template += `    export type ${field} = {\n`;
+            for (const key in keyTypes) {
+                const types = Array.from(keyTypes[key]).join(" | ");
+                template += `        ${serializeField(key)}?: ${types};\n`;
+            }
+            template += `    };\n\n`;
         }
     }
-    // generate interface
     template += "    export interface Record {\n";
-    var indexField = null;
-    for (var field in convert) {
-        // var fieldType = convert[field] !== '' ? convert[field].toLowerCase() : 'string';
-        // console.log(`generate interface field: ${field}, convert[field]: ${convert[field]}`);
-        var fieldType = 'string';
-        if (convert[field] != '') {
+    let indexField = null;
+    for (const field in convert) {
+        let fieldType = "string";
+        if (convert[field] != "") {
             if (convert[field] == EnumStr) {
                 fieldType = field;
             }
@@ -128,67 +205,154 @@ function csv2ts(csvString, moduleName) {
                 indexField = field;
             }
             else if (convert[field] == EnumArrayString) {
-                fieldType = field + '[]';
+                fieldType = field + "[]";
+            }
+            else if (convert[field] == ObjectStr) {
+                fieldType = field;
+            }
+            else if (convert[field].startsWith(RefPrefix) && convert[field].endsWith(RefSuffix)) {
+                const refModule = convert[field].slice(RefPrefix.length, -RefSuffix.length);
+                const refModuleName = changeCase.pascalCase(refModule);
+                fieldType = `${refModuleName}.Record`;
+            }
+            else if (parseRefEnum(convert[field])) {
+                const refEnum = parseRefEnum(convert[field]);
+                const refModuleName = changeCase.pascalCase(refEnum.refModule);
+                fieldType = refEnum.isArray ? `${refModuleName}.${refEnum.refField}[]` : `${refModuleName}.${refEnum.refField}`;
             }
             else {
                 fieldType = convert[field].toLowerCase();
             }
         }
-        field = serializeField(field);
-        template += "        ".concat(field, ": ").concat(fieldType, ";\n");
+        const serializedField = serializeField(field);
+        template += `        ${serializedField}: ${fieldType};\n`;
     }
-    template += '    };\n\n';
-    // remove object when index is empty
+    template += "    };\n\n";
     if (indexField) {
-        result = result.filter(function (v) {
-            return v[indexField] !== '';
+        const filteredResult = result.filter((v) => {
+            return v[indexField] !== "";
         });
+        for (let i = 0; i < filteredResult.length; i++) {
+            result[i] = filteredResult[i];
+        }
+        result.length = filteredResult.length;
     }
-    // generate table
-    template += "    export const List: Record[] = ";
-    // console.log(prettyFormat(result, op));
-    template += json5.stringify(result, null, 4).replace(/\n/g, '\n    ');
-    template += ';\n\n';
+    template += "    export const List: Record[] = [\n";
+    for (let i = 0; i < result.length; i++) {
+        const row = result[i];
+        template += "        {\n";
+        for (const field in convert) {
+            let value = row[field];
+            if (convert[field].startsWith(RefPrefix) && convert[field].endsWith(RefSuffix)) {
+                const refModule = convert[field].slice(RefPrefix.length, -RefSuffix.length);
+                const refModuleName = changeCase.pascalCase(refModule);
+                template += `            ${serializeField(field)}: ${refModuleName}.Map[${JSON.stringify(value)}],\n`;
+            }
+            else {
+                template += `            ${serializeField(field)}: ${json5.stringify(value)},\n`;
+            }
+        }
+        template += "        }";
+        if (i < result.length - 1) {
+            template += ",";
+        }
+        template += "\n";
+    }
+    template += "    ];\n\n";
     if (indexField != null) {
         template += "    export const Map: { [id: string]: Record } = {};\n";
-        template += "    for (const v of List) { Map[v.".concat(indexField, "] = v; };\n\n");
+        template += `    for (const v of List) { Map[v.${indexField}] = v; };\n\n`;
     }
     template += "};";
     return template;
 }
-/**
- * serialize interface field
- * @param {string} field
- */
 function serializeField(key) {
-    var obj = {};
+    const obj = {};
     obj[key] = true;
-    var objString = json5.stringify(obj);
-    // console.log('serializeField:', json5.stringify(obj))
+    const objString = json5.stringify(obj);
     return objString.includes("'") ? "'" + key + "'" : key;
 }
+function parseObject(str) {
+    const result = {};
+    const trimmed = str.trim();
+    if (trimmed === "") {
+        return result;
+    }
+    const pairs = trimmed.split(",");
+    for (const pair of pairs) {
+        const colonIndex = pair.indexOf(":");
+        if (colonIndex > 0) {
+            const key = pair.slice(0, colonIndex).trim();
+            const value = pair.slice(colonIndex + 1).trim();
+            result[key] = parseObjectValue(value);
+        }
+    }
+    return result;
+}
+function parseObjectValue(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value === "")
+        return "";
+    const num = Number(value);
+    if (!isNaN(num)) {
+        return num;
+    }
+    return value;
+}
+function getTypeName(value) {
+    if (typeof value === "number")
+        return "number";
+    if (typeof value === "boolean")
+        return "boolean";
+    return "string";
+}
+function parseRefEnum(typeStr) {
+    if (typeStr.startsWith(RefEnumPrefix)) {
+        let isArray = false;
+        let inner = typeStr;
+        if (typeStr.endsWith(RefEnumArraySuffix)) {
+            isArray = true;
+            inner = typeStr.slice(0, -RefEnumArraySuffix.length) + RefSuffix;
+        }
+        if (inner.endsWith(RefSuffix)) {
+            const content = inner.slice(RefEnumPrefix.length, -RefSuffix.length);
+            const dotIndex = content.lastIndexOf(".");
+            if (dotIndex > 0) {
+                const refModule = content.slice(0, dotIndex);
+                const refField = content.slice(dotIndex + 1);
+                return { refModule, refField, isArray };
+            }
+        }
+    }
+    return null;
+}
 function GetFileExt(filePath) {
-    var pathObject = path.parse(filePath);
+    const pathObject = path.parse(filePath);
     return pathObject.ext.slice(1);
 }
 function GetTsString(filePath) {
-    var pathObject = path.parse(filePath);
-    var handle = exports.Convert[GetFileExt(filePath)];
+    const pathObject = path.parse(filePath);
+    const handle = exports.Convert[GetFileExt(filePath)];
     if (handle) {
-        var moduleName = changeCase.pascalCase(pathObject.base);
-        var fileString = fs.readFileSync(filePath).toString();
-        if (fileString.charAt(0) === '\uFEFF')
+        const moduleName = changeCase.pascalCase(pathObject.base);
+        let fileString = fs.readFileSync(filePath).toString();
+        if (fileString.charAt(0) === "\uFEFF")
             fileString = fileString.substr(1);
         return handle(fileString, moduleName);
     }
     else {
-        return '';
+        return "";
     }
 }
 function GetTsStringFromFileList(fileList) {
-    return fileList.map(function (filePath) {
+    return fileList
+        .map(function (filePath) {
         return GetTsString(filePath);
-    }).join('\n\n');
+    })
+        .join("\n\n");
 }
 function GetValidFileList(fileList) {
     return fileList.filter(function (filePath) {
@@ -196,21 +360,11 @@ function GetValidFileList(fileList) {
     });
 }
 function startConvert(dir, outDir, merge) {
-    var fileList = fs.readdirSync(dir);
-    if (merge) {
-        fileList = GetValidFileList(fileList).map(function (filename) {
-            return path.join(dir, filename);
-        });
-        var mergeFile = path.join(outDir, merge);
-        fs.writeFileSync(mergeFile, GetTsStringFromFileList(fileList), { encoding: 'utf-8' });
-        console.log("config2ts, ".concat(fileList.length, " config files, merge into: ").concat(mergeFile));
-    }
-    else {
-        GetValidFileList(fileList).forEach(function (filename) {
-            var target = path.join(outDir, "".concat(filename, ".ts"));
-            fs.writeFileSync(target, GetTsString(path.join(dir, filename)), { encoding: 'utf-8' });
-            console.log("config2ts, convert: ".concat(filename, " , to: ").concat(target));
-        });
-        console.log('config2ts convert done!');
-    }
+    const fileList = fs.readdirSync(dir);
+    const fullFileList = GetValidFileList(fileList).map(function (filename) {
+        return path.join(dir, filename);
+    });
+    const mergeFile = path.join(outDir, merge);
+    fs.writeFileSync(mergeFile, GetTsStringFromFileList(fullFileList), { encoding: "utf-8" });
+    console.log(`config2ts, ${fullFileList.length} config files, merge into: ${mergeFile}`);
 }

package/lib/main.d.ts

@@ -1,9 +1 @@
-declare var fs: any;
-declare var path: any;
-declare var program: any;
-declare var config2ts: any;
-declare const options: any;
-declare var dir: any;
-declare var outDir: any;
-declare var merge: any;
-declare var fileList: any;
+export {};

package/lib/main.js

@@ -1,24 +1,58 @@
-var fs = require("fs");
-var path = require("path");
-var program = require("commander");
-var config2ts = require("./config2ts");
-program.version(require(path.join(__dirname, '..', 'package.json'))['version']);
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commander_1 = require("commander");
+const config2ts_1 = require("./config2ts");
+const pkgPath = path.join(__dirname, "..", "package.json");
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+const program = new commander_1.Command();
 program
-    .option('-d, --dir <path>', 'set convert path. default: ./')
-    .option('-o, --outDir <path>', 'set outDir path. default: ./')
-    .option('-m, --merge <name>', 'merge all to one ts file.')
+    .version(pkg.version)
+    .option("-n, --name <name>", "output file name", "csv.ts")
+    .option("-d, --dir <path>", "set convert path", ".")
+    .option("-o, --outDir <path>", "set outDir path")
     .parse(process.argv);
-var options = program.opts();
+const options = program.opts();
 console.log(options);
-var dir = options['dir'] || '.';
-dir = path.resolve(dir);
-console.log('dir:', dir);
-var outDir = options['outDir'] || dir;
-outDir = path.resolve(outDir);
-console.log('outDir:', outDir);
+const dir = path.resolve(options.dir);
+console.log("dir:", dir);
+let outDir = options.outDir ? path.resolve(options.outDir) : dir;
+console.log("outDir:", outDir);
 if (!fs.existsSync(outDir)) {
     fs.mkdirSync(outDir, { recursive: true });
 }
-var merge = options['merge'];
-var fileList = fs.readdirSync(dir);
-config2ts.startConvert(dir, outDir, merge);
+(0, config2ts_1.startConvert)(dir, outDir, options.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "config2ts",
-  "version": "2.3.3",
+  "version": "2.4.0",
   "description": "convert config to ts file.",
   "main": "lib/config2ts.js",
   "types": "lib/config2ts.d.ts",
@@ -13,7 +13,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "convert": "node ./bin/config2ts -d ./config -o ./config",
+    "convert": "node ./bin/config2ts -n total.ts -d ./config -o ./config",
     "test": "jest",
     "watch-test": "node_modules/.bin/jest --watch"
   },