config2ts 2.5.6 → 2.5.7

package/README.md

@@ -31,12 +31,12 @@ config2ts -d config -o dist -n csv.ts -a public
 
 * `Number` support Infinity and NaN
 * `Enum` support empty string type
-* `Enum[]` do not include empty string type
+* `Enum[]` union contains every value actually present in the data (including `""` for empty slots)
 * `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
+* `Object[]` parse comma-separated `key:value` slots — each slot becomes one object (`num:1,,str:a,` makes `[{num:1},{},{str:'a'},{}]`), generates a dedicated element `type` merging all keys with the field typed as `type[]`
+* Array convention (`String[]`/`Number[]`/`Enum[]`/`RefEnum[...] []`/`Object[]`): raw cell values are normalized (line breaks removed, whitespace trimmed); an empty cell generates `[]`; otherwise n commas make n+1 slots and every slot is kept (including interior or trailing ones) so parallel arrays stay index-aligned. Empty slots use the type's own zero value — `''` for string/enum/ref-enum, `0` for number, `{}` for objects; `null` is never generated
 * unrecognized field types fall back to `string` and print a warning (check for typos)
 
 ## assets2ts

package/lib/config2ts.js

@@ -91,6 +91,7 @@ function csv2ts(csvString, moduleName) {
         }
         else {
             for (const k in d) {
+                d[k] = normalizeCell(d[k]);
                 if (convert[k] === ObjectStr) {
                     d[k] = parseObject(d[k]);
                 }
@@ -101,10 +102,10 @@ function csv2ts(csvString, moduleName) {
                     d[k] = global[convert[k]](d[k]);
                 }
                 else if (convert[k] === "String[]" || convert[k] === "Enum[]") {
-                    d[k] = splitArrayValues(d[k]);
+                    d[k] = splitStringArray(d[k]);
                 }
                 else if (convert[k] === "Number[]") {
-                    d[k] = splitArrayValues(d[k]).map((val) => Number(val));
+                    d[k] = splitStringArray(d[k]).map((val) => Number(val));
                 }
                 else if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
                     if (d[k] === "") {
@@ -114,7 +115,7 @@ function csv2ts(csvString, moduleName) {
                 else if (parseRefEnum(convert[k])) {
                     const refEnum = parseRefEnum(convert[k]);
                     if (refEnum.isArray) {
-                        d[k] = splitArrayValues(d[k]);
+                        d[k] = splitStringArray(d[k]);
                     }
                     else {
                         if (d[k] === "") {
@@ -286,21 +287,27 @@ function parseObject(str) {
     }
     return result;
 }
-function parseObjectArray(str) {
-    return str
-        .split(";")
-        .map((part) => part.trim())
-        .filter((part) => part !== "")
-        .map((part) => parseObject(part));
+// Normalize a raw cell value: drop line-break artifacts (e.g. Excel/CSV \r\n)
+// and surrounding whitespace so all downstream parsing sees clean text.
+function normalizeCell(str) {
+    return String(str).replace(/\r\n?|\n/g, "").trim();
 }
-// Split a comma-separated array cell, trimming and dropping empty segments
-// so stray/leading/trailing commas never produce phantom elements.
+// Split a comma-separated array cell: n commas make n+1 slots and every slot
+// is kept (including an interior or trailing empty one), so parallel arrays
+// stay index-aligned. Empty slots follow the element's own parsing rule
+// ('' for strings/enums, 0 for numbers, {} for objects); null is never emitted.
 // An empty cell resolves to an empty array.
-function splitArrayValues(str) {
-    return str
-        .split(",")
-        .map((v) => v.trim())
-        .filter((v) => v !== "");
+function splitStringArray(str) {
+    if (str === "") {
+        return [];
+    }
+    return str.split(",").map((v) => v.trim());
+}
+function parseObjectArray(str) {
+    if (str === "") {
+        return [];
+    }
+    return str.split(",").map((part) => parseObject(part));
 }
 function parseObjectValue(value) {
     if (value === "true")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "config2ts",
-  "version": "2.5.6",
+  "version": "2.5.7",
   "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",