config2ts 2.6.0 → 2.6.1

package/README.md

@@ -36,7 +36,7 @@ config2ts -d config -o dist -n csv.ts -a public
 * `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/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
-* `Template[file]` inherits a whole row from another table and overrides selected fields: a cell is `<baseId>|<key>:<value>,<key>:<value>` — a pipe separates the base row id from Object-style override pairs (e.g. `101|damage:150,range:8`), emitting `{ ...file.Map["101"], damage: 150, range: 8 }` typed `File.Record`; with no overrides the cell is just the id and emits a plain `file.Map["id"]` like `Ref`. `Template[file][]` separates entries with `;` (the same element separator as `Object[]`), e.g. `101|damage:150;102|heal:500` emits `[{ ...file.Map["101"], damage: 150 },{ ...file.Map["102"], heal: 500 }]`. Override key typos and value-type mismatches fail at tsc compile time; overrides are flat top-level fields only, and the target table must have an Index/Map (same file-ordering rule as `Ref`)
+* `Template[file]` inherits a whole row from another table and overrides selected fields: a cell is `<baseId>|<key>:<value>,<key>:<value>` — a pipe separates the base row id from override pairs (e.g. `101|damage:150,range:8`), emitting `{ ...file.Map["101"], damage: 150, range: 8 }` typed `File.Record`; with no overrides the cell is just the id and emits a plain `file.Map["id"]` like `Ref`. Override values may be bare scalars or bracket-wrapped composites mirroring the generated TS syntax — arrays as `[v1,v2]` (e.g. `Params:[6,2.07]`, required for array-typed fields; a bare `Params:6,2.07` gets chopped by the pair comma and prints a warning) and flat objects as `{k:v,k:v}`. `Template[file][]` separates entries with `;` (the same element separator as `Object[]`), e.g. `101|damage:150;102|heal:500` emits `[{ ...file.Map["101"], damage: 150 },{ ...file.Map["102"], heal: 500 }]`. Override key typos and value-type mismatches fail at tsc compile time; overrides are flat top-level fields (no dot-path deep merge), and the target table must have an Index/EnumIndex Map (same file-ordering rule as `Ref`)
 * `Object` parse `key:value,key:value` format, auto-infer value types (number/boolean/string), generates a dedicated `type` that merges all keys
 * `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

package/lib/config2ts.js

@@ -139,8 +139,9 @@ function csv2ts(csvString, moduleName) {
                 }
                 else if (parseTemplate(convert[k])) {
                     const template = parseTemplate(convert[k]);
+                    const templateContext = { moduleName, field: k, row: i };
                     if (template.isArray) {
-                        const entries = d[k] === "" ? [] : d[k].split(TemplateEntrySeparator).map((part) => parseTemplateEntry(part));
+                        const entries = d[k] === "" ? [] : d[k].split(TemplateEntrySeparator).map((part) => parseTemplateEntry(part, templateContext));
                         for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
                             if (entries[entryIndex].baseId === "") {
                                 console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" template array entry ${entryIndex + 1} has an empty base id`);
@@ -152,7 +153,7 @@ function csv2ts(csvString, moduleName) {
                         if (d[k] === "") {
                             console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" template value is empty`);
                         }
-                        const entry = parseTemplateEntry(d[k]);
+                        const entry = parseTemplateEntry(d[k], templateContext);
                         if (d[k] !== "" && entry.baseId === "") {
                             console.warn(`[config2ts] warning: ${moduleName} row ${i} field "${k}" template base id is empty`);
                         }
@@ -478,18 +479,88 @@ function parseTemplate(typeStr) {
     return null;
 }
 // Parse one Template cell entry: "<baseId>|<key>:<value>,<key>:<value>".
-// The part before the first '|' is the base row id; the part after it reuses
-// the Object rule for the override pairs. No '|' means zero overrides, which
-// is equivalent to a plain Ref.
-function parseTemplateEntry(str) {
+// The part before the first '|' is the base row id; the part after it holds
+// the override pairs. Pair splitting is bracket-aware, so composite values
+// are not chopped apart: array values are wrapped in [...] (e.g.
+// "Params:[6,2.07]") and flat object values in {...} (e.g.
+// "params:{damage:100,range:5}"), mirroring the generated TypeScript syntax.
+// No '|' means zero overrides, which is equivalent to a plain Ref.
+function parseTemplateEntry(str, context) {
     const separatorIndex = str.indexOf(TemplateOverrideSeparator);
     if (separatorIndex < 0) {
         return { baseId: str.trim(), overrides: {} };
     }
     const baseId = str.slice(0, separatorIndex).trim();
-    const overrides = parseObject(str.slice(separatorIndex + 1));
+    const overrides = parseTemplateOverrides(str.slice(separatorIndex + 1), context);
     return { baseId, overrides };
 }
+// Split a string on a separator while ignoring separators inside [] / {}
+// brackets, so commas inside composite values stay intact.
+function splitBracketAware(str, separator) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < str.length; i++) {
+        const ch = str[i];
+        if (ch === "[" || ch === "{") {
+            depth++;
+        }
+        else if (ch === "]" || ch === "}") {
+            if (depth > 0)
+                depth--;
+        }
+        else if (ch === separator && depth === 0) {
+            parts.push(str.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(str.slice(start));
+    return parts;
+}
+// Parse the override part of a Template entry. Scalar pairs reuse the Object
+// rule ("key:value"); a stray segment without a key (e.g. the "2.07" produced
+// by writing "Params:6,2.07" without brackets) is reported instead of being
+// silently dropped.
+function parseTemplateOverrides(str, context) {
+    const overrides = {};
+    for (const pair of splitBracketAware(str, ",")) {
+        const colonIndex = pair.indexOf(":");
+        const trimmedPair = pair.trim();
+        if (colonIndex <= 0) {
+            if (trimmedPair !== "" && context) {
+                console.warn(`[config2ts] warning: ${context.moduleName} row ${context.row} field "${context.field}" template override segment "${trimmedPair}" is not a key:value pair and was ignored; wrap array values in brackets, e.g. Params:[6,2.07]`);
+            }
+            continue;
+        }
+        const key = pair.slice(0, colonIndex).trim();
+        overrides[key] = parseOverrideValue(pair.slice(colonIndex + 1));
+    }
+    return overrides;
+}
+// Parse one override value: "[...]" resolves to an array (elements inferred
+// like Object values, flat {...} elements are supported), "{...}" resolves to
+// a flat object (same rule as the Object type), and anything else resolves to
+// a scalar (number/boolean/string).
+function parseOverrideValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        const inner = trimmed.slice(1, -1).trim();
+        if (inner === "") {
+            return [];
+        }
+        return splitBracketAware(inner, ",").map((element) => {
+            const elementTrimmed = element.trim();
+            if (elementTrimmed.startsWith("{") && elementTrimmed.endsWith("}")) {
+                return parseObject(elementTrimmed.slice(1, -1));
+            }
+            return parseObjectValue(elementTrimmed);
+        });
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return parseObject(trimmed.slice(1, -1));
+    }
+    return parseObjectValue(trimmed);
+}
 // Serialize one parsed Template entry to runtime code. Entries without
 // overrides emit a plain ref (same as Ref: `Module.Map["id"]`); entries with
 // overrides spread the base record and apply the overrides on top. Because

package/package.json

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