config2ts 2.5.4 → 2.5.6

package/README.md

@@ -27,6 +27,7 @@ config2ts -d config -o dist -n csv.ts -a public
 | RefEnum    | namespace.type    |
 |  RefEnum[] |  namespace.type[] |
 |   Object   |   type (Record)   |
+|  Object[]  | type[] (Record[]) |
 
 * `Number` support Infinity and NaN
 * `Enum` support empty string type
@@ -34,6 +35,9 @@ config2ts -d config -o dist -n csv.ts -a public
 * `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
+* `Object[]` parse `key:value,key:value;key:value,key:value` format (`;` separates objects, `,` separates key-value pairs), empty value generates `[]`, generates a dedicated element `type` with the field typed as `type[]`
+* Array empty-data convention (`String[]`/`Number[]`/`Enum[]`/`RefEnum[...] []`/`Object[]`): an empty cell generates `[]`; empty segments from stray, leading or trailing separators (e.g. `"a,,b"`, `"1,,3"`, `"x:1;;y:2"`) are skipped — no phantom `""`, `0` or `{}` elements
+* unrecognized field types fall back to `string` and print a warning (check for typos)
 
 ## assets2ts
 

package/lib/config2ts.js

@@ -50,6 +50,7 @@ const EnumIndexStr = "EnumIndex";
 const EnumArrayString = "Enum[]";
 const IndexStr = "Index";
 const ObjectStr = "Object";
+const ObjectArrayString = "Object[]";
 const RefPrefix = "Ref[";
 const RefSuffix = "]";
 const RefEnumPrefix = "RefEnum[";
@@ -82,6 +83,9 @@ function csv2ts(csvString, moduleName) {
                 if (parseRefEnum(convert[k])) {
                     refEnumFields.push(k);
                 }
+                if (!isKnownType(convert[k])) {
+                    console.warn(`[config2ts] warning: ${moduleName} field "${k}" has unrecognized type "${convert[k]}", values will be treated as string`);
+                }
             }
             return null;
         }
@@ -90,27 +94,17 @@ function csv2ts(csvString, moduleName) {
                 if (convert[k] === ObjectStr) {
                     d[k] = parseObject(d[k]);
                 }
+                else if (convert[k] === ObjectArrayString) {
+                    d[k] = parseObjectArray(d[k]);
+                }
                 else if (typeof global[convert[k]] === "function") {
                     d[k] = global[convert[k]](d[k]);
                 }
-                else if (convert[k] === "String[]") {
-                    if (d[k] === "") {
-                        d[k] = [];
-                    }
-                    else {
-                        d[k] = d[k].trim().split(",").map((v) => v.trim());
-                    }
+                else if (convert[k] === "String[]" || convert[k] === "Enum[]") {
+                    d[k] = splitArrayValues(d[k]);
                 }
                 else if (convert[k] === "Number[]") {
-                    d[k] = d[k].trim().split(",").map((val) => Number(val));
-                }
-                else if (convert[k] === "Enum[]") {
-                    if (d[k] === "") {
-                        d[k] = [];
-                    }
-                    else {
-                        d[k] = d[k].trim().split(",").map((v) => v.trim());
-                    }
+                    d[k] = splitArrayValues(d[k]).map((val) => Number(val));
                 }
                 else if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
                     if (d[k] === "") {
@@ -120,12 +114,7 @@ function csv2ts(csvString, moduleName) {
                 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());
-                        }
+                        d[k] = splitArrayValues(d[k]);
                     }
                     else {
                         if (d[k] === "") {
@@ -172,15 +161,18 @@ 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) {
+        else if (convert[field] == ObjectStr || convert[field] == ObjectArrayString) {
             const keyTypes = {};
+            const isArray = convert[field] == ObjectArrayString;
             for (const row of result) {
-                const objValue = row[field];
-                for (const key in objValue) {
-                    if (!keyTypes[key]) {
-                        keyTypes[key] = new Set();
+                const objValues = isArray ? row[field] : [row[field]];
+                for (const objValue of objValues) {
+                    for (const key in objValue) {
+                        if (!keyTypes[key]) {
+                            keyTypes[key] = new Set();
+                        }
+                        keyTypes[key].add(getTypeName(objValue[key]));
                     }
-                    keyTypes[key].add(getTypeName(objValue[key]));
                 }
             }
             template += `    export type ${field} = {\n`;
@@ -212,6 +204,9 @@ function csv2ts(csvString, moduleName) {
             else if (convert[field] == ObjectStr) {
                 fieldType = field;
             }
+            else if (convert[field] == ObjectArrayString) {
+                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);
@@ -291,6 +286,22 @@ function parseObject(str) {
     }
     return result;
 }
+function parseObjectArray(str) {
+    return str
+        .split(";")
+        .map((part) => part.trim())
+        .filter((part) => part !== "")
+        .map((part) => parseObject(part));
+}
+// Split a comma-separated array cell, trimming and dropping empty segments
+// so stray/leading/trailing commas never produce phantom elements.
+// An empty cell resolves to an empty array.
+function splitArrayValues(str) {
+    return str
+        .split(",")
+        .map((v) => v.trim())
+        .filter((v) => v !== "");
+}
 function parseObjectValue(value) {
     if (value === "true")
         return true;
@@ -311,6 +322,25 @@ function getTypeName(value) {
         return "boolean";
     return "string";
 }
+function isKnownType(typeStr) {
+    if (typeStr === "") {
+        return true;
+    }
+    const knownTypes = [EnumStr, EnumIndexStr, EnumArrayString, IndexStr, ObjectStr, ObjectArrayString, "String[]", "Number[]"];
+    if (knownTypes.includes(typeStr)) {
+        return true;
+    }
+    if (typeStr.startsWith(RefPrefix) && typeStr.endsWith(RefSuffix)) {
+        return true;
+    }
+    if (parseRefEnum(typeStr)) {
+        return true;
+    }
+    if (typeof global[typeStr] === "function") {
+        return true;
+    }
+    return false;
+}
 function parseRefEnum(typeStr) {
     if (typeStr.startsWith(RefEnumPrefix)) {
         let isArray = false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "config2ts",
-  "version": "2.5.4",
-  "description": "convert config to ts file.",
+  "version": "2.5.6",
+  "description": "Generate type-safe TypeScript from CSV/INI/TOML config tables — inferred types, enums, cross-table references, and a typed asset index, all from one CLI command.",
   "main": "lib/config2ts.js",
   "types": "lib/config2ts.d.ts",
   "bin": {