config2ts 2.5.7 → 2.5.9

package/README.md

@@ -33,10 +33,10 @@ config2ts -d config -o dist -n csv.ts -a public
 * `Enum` support 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
+* `Ref` / `RefEnum` reference another csv's Record/enum by id: `Ref[file]` is one row (`file.Map["id"]`), `Ref[file][]` is an array of rows with comma-separated ids (`[file.Map["1"],file.Map["2"]]`, typed `File.Record[]`); use `Object[]` for inline private structures and `Ref[]` for shared, identity-bearing rows
 * `Object` parse `key:value,key:value` format, auto-infer value types (number/boolean/string), generates a dedicated `type` that merges all keys
-* `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
+* `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

@@ -77,7 +77,7 @@ function csv2ts(csvString, moduleName) {
         if (i === 0) {
             convert = d;
             for (const k in convert) {
-                if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
+                if (parseRef(convert[k])) {
                     refFields.push(k);
                 }
                 if (parseRefEnum(convert[k])) {
@@ -107,8 +107,16 @@ function csv2ts(csvString, moduleName) {
                 else if (convert[k] === "Number[]") {
                     d[k] = splitStringArray(d[k]).map((val) => Number(val));
                 }
-                else if (convert[k].startsWith(RefPrefix) && convert[k].endsWith(RefSuffix)) {
-                    if (d[k] === "") {
+                else if (parseRef(convert[k])) {
+                    const ref = parseRef(convert[k]);
+                    if (ref.isArray) {
+                        const ids = splitStringArray(d[k]);
+                        d[k] = ids;
+                        if (ids.includes("")) {
+                            console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" ref array contains an empty id`);
+                        }
+                    }
+                    else if (d[k] === "") {
                         console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" ref value is empty`);
                     }
                 }
@@ -208,10 +216,10 @@ function csv2ts(csvString, moduleName) {
             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);
-                fieldType = `${refModuleName}.Record`;
+            else if (parseRef(convert[field])) {
+                const ref = parseRef(convert[field]);
+                const refModuleName = changeCase.pascalCase(ref.refModule);
+                fieldType = ref.isArray ? `${refModuleName}.Record[]` : `${refModuleName}.Record`;
             }
             else if (parseRefEnum(convert[field])) {
                 const refEnum = parseRefEnum(convert[field]);
@@ -241,10 +249,16 @@ function csv2ts(csvString, moduleName) {
         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`;
+            if (parseRef(convert[field])) {
+                const ref = parseRef(convert[field]);
+                const refModuleName = changeCase.pascalCase(ref.refModule);
+                if (ref.isArray) {
+                    const refs = value.map((id) => `${refModuleName}.Map[${JSON.stringify(id)}]`).join(",");
+                    template += `            ${serializeField(field)}: [${refs}],\n`;
+                }
+                else {
+                    template += `            ${serializeField(field)}: ${refModuleName}.Map[${JSON.stringify(value)}],\n`;
+                }
             }
             else {
                 template += `            ${serializeField(field)}: ${json5.stringify(value)},\n`;
@@ -292,22 +306,29 @@ function parseObject(str) {
 function normalizeCell(str) {
     return String(str).replace(/\r\n?|\n/g, "").trim();
 }
-// 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
+// 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, {} for objects); null is never emitted.
+// ('' for strings/enums, 0 for numbers); null is never emitted.
 // An empty cell resolves to an empty array.
+// 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));
+    return str.split(";").map((part) => parseObject(part));
 }
 function parseObjectValue(value) {
     if (value === "true")
@@ -337,7 +358,7 @@ function isKnownType(typeStr) {
     if (knownTypes.includes(typeStr)) {
         return true;
     }
-    if (typeStr.startsWith(RefPrefix) && typeStr.endsWith(RefSuffix)) {
+    if (parseRef(typeStr)) {
         return true;
     }
     if (parseRefEnum(typeStr)) {
@@ -348,6 +369,26 @@ function isKnownType(typeStr) {
     }
     return false;
 }
+// Parse Ref[module] (single) and Ref[module][] (array of row references).
+// Note: "RefEnum[...]" starts with "RefE", so it never collides with "Ref[".
+function parseRef(typeStr) {
+    if (!typeStr.startsWith(RefPrefix)) {
+        return null;
+    }
+    let isArray = false;
+    let inner = typeStr;
+    if (typeStr.endsWith(RefEnumArraySuffix)) {
+        isArray = true;
+        inner = typeStr.slice(0, -RefEnumArraySuffix.length) + RefSuffix;
+    }
+    if (inner.startsWith(RefPrefix) && inner.endsWith(RefSuffix)) {
+        const refModule = inner.slice(RefPrefix.length, -RefSuffix.length);
+        if (refModule !== "") {
+            return { refModule, isArray };
+        }
+    }
+    return null;
+}
 function parseRefEnum(typeStr) {
     if (typeStr.startsWith(RefEnumPrefix)) {
         let isArray = false;

package/package.json

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