config2ts 2.5.6 → 2.5.8

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[]` separates objects with `;` while commas still separate `key:value` pairs inside each object (same syntax as the `Object` type), e.g. `num:1,,str:a;num:2` makes `[{num:1,str:'a'},{num:2}]`, a bare `;` makes `[{},{}]`; generates a dedicated element `type` merging all keys with the field typed as `type[]`
+* Array convention: primitive arrays (`String[]`/`Number[]`/`Enum[]`/`RefEnum[...] []`) separate elements with `,` and `Object[]` separates objects with `;`; raw cell values are normalized (line breaks removed, whitespace trimmed); an empty cell generates `[]`; otherwise n separators 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 empty object slots; `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,34 @@ 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 primitive-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); 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 !== "");
+// Note: Object[] uses semicolons as element separator (see parseObjectArray),
+// because commas already separate key:value pairs inside an object.
+function splitStringArray(str) {
+    if (str === "") {
+        return [];
+    }
+    return str.split(",").map((v) => v.trim());
+}
+// Object[] separates objects with semicolons (commas are reserved for the
+// key:value pairs inside an object, same syntax as the Object type); each
+// semicolon slot is parsed by the same object rule, so stray empty pairs within
+// an object (e.g. "num:1,,str:a") are ignored while an empty object slot between
+// semicolons (e.g. "a:1;;b:2") becomes an empty object placeholder.
+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.8",
   "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",