config2ts 2.3.4 → 2.5.0

package/README.md

@@ -8,28 +8,82 @@ run command: `npm install -g config2ts`
 
 # how to use
 
-config2ts -d config -o dist -m csv.ts
+config2ts -d config -o dist -n csv.ts -a public
 
 # support type
 
-| csv field | typescript type |
-| :-------: | :-------------: |
-|   Index   |     string      |
-|  String   |     string      |
-|  Number   |     number      |
-|  Boolean  |     boolean     |
-|   Enum    |      type       |
-| EnumIndex |      type       |
-| String[]  |    string[]     |
-| Number[]  |    number[]     |
-|  Enum[]   |     type[]      |
+| csv field  |  typescript type  |
+| :--------: | :---------------: |
+|   Index    |      string       |
+|   String   |      string       |
+|   Number   |      number       |
+|  Boolean   |     boolean       |
+|    Enum    |       type        |
+| EnumIndex  |       type        |
+| String[]   |     string[]      |
+| Number[]   |     number[]      |
+|  Enum[]    |      type[]       |
+|    Ref     | namespace.Record  |
+| RefEnum    | namespace.type    |
+|  RefEnum[] |  namespace.type[] |
+|   Object   |   type (Record)   |
 
 * `Number` support Infinity and NaN
 * `Enum` support empty string type
 * `Enum[]` do not include empty string type
 * `EnumIndex` will generate index type, and will use `Enum` type to generate interface
+* `Ref` / `RefEnum` reference another csv's Record/type by id
+* `Object` parse `key:value,key:value` format, auto-infer value types (number/boolean/string), generates a dedicated `type` that merges all keys
 
-## Usage
+## assets2ts
+
+Scan assets directory and generate an `assets.ts` index file with nested resource tree.
+
+- `-a, --assets <path>` set assets resource directory. default: `public`
+- Output file: `assets.ts` (alongside the merged config file)
+- Directory/filenames are converted to camelCase keys
+- `type` field uses file extension (lowercase), e.g. `'png'`, `'mp3'`, `'svg'`
+- Directories containing 2+ files of the same extension get a dedicated type (e.g. `PngAsset`, `Mp3Asset`) and `as Record<string, XxxAsset>` annotation
+- Directories with ≤1 file or mixed extensions do not get a type annotation
+- Nested directories are supported (e.g. `public/sub/image/`)
+
+### generated example
+
+```typescript
+// Auto Generated by config2ts, DO NOT EDIT
+
+export type Mp3Asset = { path: string; type: 'mp3' };
+export type PngAsset = { path: string; type: 'png' };
+export type SvgAsset = { path: string; type: 'svg' };
+
+export const RES = {
+    public: {
+        image: {
+            adjustHorizontal: {path:'public/image/adjust-horizontal.png',type:'png'},
+            direction: {path:'public/image/direction.png',type:'png'}
+        } as Record<string, PngAsset>,
+        music: {
+            effect1: {path:'public/music/effect1.mp3',type:'mp3'},
+            effect2: {path:'public/music/effect2.mp3',type:'mp3'}
+        } as Record<string, Mp3Asset>,
+        singleFile: {
+            effect1: {path:'public/single-file/effect1.mp3',type:'mp3'}
+        }
+    }
+};
+```
+
+### usage
+
+```typescript
+import { RES } from "./assets";
+
+const meta = RES.public.image.adjustHorizontal;
+// meta.path → 'public/image/adjust-horizontal.png'
+// meta.type → 'png'
+```
+
+## Options
 
 ```
   Options:
@@ -38,7 +92,14 @@ config2ts -d config -o dist -m csv.ts
     -V, --version          output the version number
     -d, --dir <path>       set convert path. default: ./
     -o, --outDir <path>    set outDir path. default: ./
-    -p, --prefix <prefix>  set interface prefix. default: ""
-    -s, --suffix <suffix>  set interface suffix. default: "Csv"
-    -m, --merge <name>     merge all to one ts file. default: csv.ts
+    -n, --name <name>      output file name. default: csv.ts
+    -a, --assets <path>    set assets resource directory for asset index. default: public
 ```
+
+## supported file formats
+
+| format | extension |
+| :----: | :-------: |
+|  csv   |   .csv    |
+|  ini   |   .ini    |
+|  toml  |   .toml   |

package/lib/config2ts.d.ts

@@ -1,7 +1,8 @@
 type ConvertHandler = (str: string, moduleName: string) => string;
 export declare const Convert: Record<string, ConvertHandler>;
+export declare function assets2ts(assetsDir: string): string;
 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 declare function startConvert(dir: string, outDir: string, merge: string, assetsDir?: string): void;
 export {};

package/lib/config2ts.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Convert = void 0;
+exports.assets2ts = assets2ts;
 exports.GetTsString = GetTsString;
 exports.GetTsStringFromFileList = GetTsStringFromFileList;
 exports.GetValidFileList = GetValidFileList;
@@ -48,10 +49,12 @@ 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 = "][]";
+const AutoGenHeader = "// Auto Generated by config2ts, DO NOT EDIT\n\n";
 exports.Convert = {
     ini: function (str, moduleName) {
         const obj = toml.parse(str);
@@ -84,7 +87,10 @@ function csv2ts(csvString, moduleName) {
         }
         else {
             for (const k in d) {
-                if (typeof global[convert[k]] === "function") {
+                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[]") {
@@ -166,6 +172,24 @@ function csv2ts(csvString, moduleName) {
             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`;
+        }
     }
     template += "    export interface Record {\n";
     let indexField = null;
@@ -185,6 +209,9 @@ function csv2ts(csvString, moduleName) {
             else if (convert[field] == EnumArrayString) {
                 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);
@@ -247,6 +274,43 @@ function serializeField(key) {
     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;
@@ -271,6 +335,123 @@ function GetFileExt(filePath) {
     const pathObject = path.parse(filePath);
     return pathObject.ext.slice(1);
 }
+function scanDir(dir, basePath) {
+    const node = {};
+    let hasContent = false;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const key = changeCase.camelCase(entry.name);
+            const childNode = scanDir(fullPath, path.posix.join(basePath, entry.name));
+            if (childNode !== null) {
+                node[key] = childNode;
+                hasContent = true;
+            }
+        }
+        else if (entry.isFile()) {
+            const parsed = path.parse(entry.name);
+            const ext = parsed.ext.slice(1).toLowerCase();
+            const key = changeCase.camelCase(parsed.name);
+            const relPath = path.posix.join(basePath, entry.name);
+            node[key] = { path: relPath, type: ext };
+            hasContent = true;
+        }
+    }
+    return hasContent ? node : null;
+}
+function isLeafNode(value) {
+    return "path" in value && "type" in value;
+}
+function getUniformType(node) {
+    const values = Object.values(node);
+    if (values.length <= 1)
+        return null;
+    let uniformType = null;
+    for (const v of values) {
+        if (!isLeafNode(v))
+            return null;
+        if (uniformType === null) {
+            uniformType = v.type;
+        }
+        else if (uniformType !== v.type) {
+            return null;
+        }
+    }
+    return uniformType;
+}
+function collectUniformDirs(node, dirTypes, exts) {
+    const ut = getUniformType(node);
+    if (ut !== null) {
+        dirTypes.set(node, ut);
+        exts.add(ut);
+        return;
+    }
+    for (const v of Object.values(node)) {
+        if (!isLeafNode(v)) {
+            collectUniformDirs(v, dirTypes, exts);
+        }
+    }
+}
+function extToTypeName(ext) {
+    return ext.charAt(0).toUpperCase() + ext.slice(1) + "Asset";
+}
+function serializeAssetNode(node, indent, uniformDirs, extTypeMap) {
+    const entries = Object.entries(node);
+    if (entries.length === 0)
+        return `${indent}{}`;
+    const ut = uniformDirs.get(node);
+    const lines = [];
+    for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        const serializedKey = serializeField(key);
+        const comma = i < entries.length - 1 ? "," : "";
+        if (isLeafNode(value)) {
+            lines.push(`${indent}${serializedKey}: {path:${json5.stringify(value.path)},type:${json5.stringify(value.type)}}${comma}`);
+        }
+        else {
+            const childUt = uniformDirs.get(value);
+            const typeAnnotation = childUt ? ` as Record<string, ${extTypeMap.get(childUt)}>` : "";
+            lines.push(`${indent}${serializedKey}: {`);
+            lines.push(serializeAssetNode(value, indent + "    ", uniformDirs, extTypeMap));
+            lines.push(`${indent}}${typeAnnotation}${comma}`);
+        }
+    }
+    return lines.join("\n");
+}
+function assets2ts(assetsDir) {
+    if (!fs.existsSync(assetsDir)) {
+        return "";
+    }
+    const dirName = path.basename(assetsDir);
+    const root = scanDir(assetsDir, dirName);
+    if (root === null) {
+        return "";
+    }
+    const uniformDirs = new Map();
+    const exts = new Set();
+    collectUniformDirs(root, uniformDirs, exts);
+    const extTypeMap = new Map();
+    const sortedExts = Array.from(exts).sort();
+    for (const ext of sortedExts) {
+        extTypeMap.set(ext, extToTypeName(ext));
+    }
+    let template = "";
+    for (const ext of sortedExts) {
+        const typeName = extTypeMap.get(ext);
+        template += `export type ${typeName} = { path: string; type: ${json5.stringify(ext)} };\n`;
+    }
+    if (sortedExts.length > 0)
+        template += "\n";
+    template += `export const RES = {\n`;
+    const rootUt = uniformDirs.get(root);
+    template += `    ${dirName}: {\n`;
+    template += serializeAssetNode(root, "        ", uniformDirs, extTypeMap);
+    const rootAnnotation = rootUt ? ` as Record<string, ${extTypeMap.get(rootUt)}>` : "";
+    template += `\n    }${rootAnnotation}\n`;
+    template += `};\n`;
+    return template;
+}
 function GetTsString(filePath) {
     const pathObject = path.parse(filePath);
     const handle = exports.Convert[GetFileExt(filePath)];
@@ -297,12 +478,20 @@ function GetValidFileList(fileList) {
         return exports.Convert[GetFileExt(filePath)] != null;
     });
 }
-function startConvert(dir, outDir, merge) {
+function startConvert(dir, outDir, merge, assetsDir) {
     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" });
+    fs.writeFileSync(mergeFile, AutoGenHeader + GetTsStringFromFileList(fullFileList), { encoding: "utf-8" });
     console.log(`config2ts, ${fullFileList.length} config files, merge into: ${mergeFile}`);
+    if (assetsDir) {
+        const assetsOutput = assets2ts(assetsDir);
+        if (assetsOutput) {
+            const assetsFile = path.join(outDir, "assets.ts");
+            fs.writeFileSync(assetsFile, AutoGenHeader + assetsOutput, { encoding: "utf-8" });
+            console.log(`assets2ts, resource dir: ${assetsDir}, output: ${assetsFile}`);
+        }
+    }
 }

package/lib/main.js

@@ -45,6 +45,7 @@ program
     .option("-n, --name <name>", "output file name", "csv.ts")
     .option("-d, --dir <path>", "set convert path", ".")
     .option("-o, --outDir <path>", "set outDir path")
+    .option("-a, --assets <path>", "set assets resource directory for asset index", "public")
     .parse(process.argv);
 const options = program.opts();
 console.log(options);
@@ -55,4 +56,8 @@ console.log("outDir:", outDir);
 if (!fs.existsSync(outDir)) {
     fs.mkdirSync(outDir, { recursive: true });
 }
-(0, config2ts_1.startConvert)(dir, outDir, options.name);
+const assetsDir = options.assets ? path.resolve(options.assets) : undefined;
+if (assetsDir) {
+    console.log("assetsDir:", assetsDir);
+}
+(0, config2ts_1.startConvert)(dir, outDir, options.name, assetsDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "config2ts",
-  "version": "2.3.4",
+  "version": "2.5.0",
   "description": "convert config to ts file.",
   "main": "lib/config2ts.js",
   "types": "lib/config2ts.d.ts",