toon-formatter 2.0.1 → 2.1.1

package/src/utils.js

@@ -11,11 +11,28 @@ export function encodeXmlReservedChars(rawXmlString) {
     if (typeof rawXmlString !== 'string') {
         return '';
     }
+    // Replace & with & but not if it's already an entity
+    return rawXmlString.replace(/&(?!#|\w+;)/g, '&');
+}
+
+/**
+ * Sanitizes a string for use as an XML tag name.
+ * @param {string} name 
+ * @returns {string} Sanitized name
+ */
+export function sanitizeTagName(name) {
+    if (typeof name !== 'string' || !name) {
+        return '_';
+    }
 
-    let encodedString = rawXmlString;
-    const ampersandRegex = /&(?!#|\w+;)/g;
-    encodedString = encodedString.replace(ampersandRegex, '&');
-    return encodedString;
+    let sanitized = name;
+    // If name starts with non-letter/underscore (e.g. digit), prepend underscore
+    if (/^[^a-zA-Z_]/.test(sanitized)) {
+        sanitized = '_' + sanitized;
+    }
+
+    // Replace invalid chars with underscore
+    return sanitized.replace(/[^a-zA-Z0-9_.]/g, '_');
 }
 
 /**
@@ -56,10 +73,16 @@ export function parseValue(val) {
     if (val === 'null') return null;
     if (val === '') return ""; // Empty string
 
-    // Number check: simplified, can be improved
-    if (!isNaN(Number(val)) && val !== '' && !val.startsWith('0') && val !== '0') return Number(val);
+    // Number check
     if (val === '0') return 0;
-    if (val.match(/^-?0\./)) return Number(val); // 0.5, -0.5
+
+    // If it starts with 0 but is not a decimal, it's a string (e.g. "0123")
+    if (val.startsWith('0') && !val.startsWith('0.') && val.length > 1) {
+        // String
+    } else {
+        const num = Number(val);
+        if (!isNaN(num) && val !== '') return num;
+    }
 
     // String unquoting
     if (val.startsWith('"') && val.endsWith('"')) {
@@ -76,8 +99,10 @@ export function parseValue(val) {
  */
 export function formatValue(v) {
     if (v === null) return "null";
+    if (v === true) return "true";
+    if (v === false) return "false";
     if (typeof v === "string") return `"${v.replace(/"/g, '\\"')}"`;
-    return v; // number, boolean
+    return String(v);
 }
 
 /**
@@ -88,62 +113,84 @@ export function formatValue(v) {
 export function extractJsonFromString(text) {
     if (!text || typeof text !== 'string') return null;
 
-    let startIndex = -1;
+    let searchStart = 0;
 
-    // Find first potential start
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === '{' || text[i] === '[') {
-            // Ignore if preceded by non-whitespace (e.g. key[2])
-            if (i > 0 && /\S/.test(text[i - 1])) {
-                continue;
+    while (searchStart < text.length) {
+        let startIndex = -1;
+
+        // Find first potential start
+        for (let i = searchStart; i < text.length; i++) {
+            if (text[i] === '{' || text[i] === '[') {
+                // Ignore if preceded by non-whitespace (e.g. key[2]), 
+                // unless it's a closing bracket/brace or XML tag end
+                if (i > 0 && /\S/.test(text[i - 1]) && !/[\}\]>]/.test(text[i - 1])) {
+                    continue;
+                }
+                startIndex = i;
+                break;
             }
-            startIndex = i;
-            break;
         }
-    }
 
-    if (startIndex === -1) return null;
+        if (startIndex === -1) return null;
 
-    let balance = 0;
-    let inQuote = false;
-    let escape = false;
+        let balance = 0;
+        let inQuote = false;
+        let escape = false;
 
-    for (let i = startIndex; i < text.length; i++) {
-        const char = text[i];
+        for (let i = startIndex; i < text.length; i++) {
+            const char = text[i];
 
-        if (escape) {
-            escape = false;
-            continue;
-        }
-
-        if (char === '\\') {
-            escape = true;
-            continue;
-        }
+            if (escape) {
+                escape = false;
+                continue;
+            }
 
-        if (char === '"') {
-            inQuote = !inQuote;
-            continue;
-        }
+            if (char === '\\') {
+                escape = true;
+                continue;
+            }
 
-        if (!inQuote) {
-            if (char === '{' || char === '[') {
-                balance++;
-            } else if (char === '}' || char === ']') {
-                balance--;
+            if (char === '"') {
+                inQuote = !inQuote;
+                continue;
             }
 
-            if (balance === 0) {
-                // Potential end
-                const candidate = text.substring(startIndex, i + 1);
-                try {
-                    JSON.parse(candidate);
-                    return candidate;
-                } catch (e) {
-                    // Continue scanning if parse fails
+            if (!inQuote) {
+                if (char === '{' || char === '[') {
+                    balance++;
+                } else if (char === '}' || char === ']') {
+                    balance--;
+                }
+
+                if (balance === 0) {
+                    const candidate = text.substring(startIndex, i + 1);
+
+
+                    // Avoid matching TOON arrays (e.g. [3]: 1, 2, 3)
+                    if (/^\s*\[\d+\]/.test(candidate)) {
+                        searchStart = i + 1;
+                        startIndex = -1;
+                        break; // Break inner for loop, restart while loop from searchStart
+                    }
+
+                    try {
+                        JSON.parse(candidate);
+                        return candidate;
+                    } catch (e) {
+                        // If balanced but not valid JSON (like {id,name}), 
+                        // it's likely a false start. Abandon this startIndex and try next.
+                        searchStart = startIndex + 1;
+                        startIndex = -1;
+                        break; // Break inner for loop, restart while loop from searchStart
+                    }
                 }
             }
         }
+
+        if (startIndex !== -1) {
+            // Reached end without balancing for this startIndex
+            searchStart = startIndex + 1;
+        }
     }
 
     return null;
@@ -157,23 +204,22 @@ export function extractJsonFromString(text) {
 export function extractXmlFromString(text) {
     if (!text || typeof text !== 'string') return null;
 
-    // Find first start tag
-    const startTagRegex = /<([a-zA-Z0-9_:-]+)(?:\s[^>]*)?\>/;
+    // Find first start tag (including self-closing)
+    const startTagRegex = /<([a-zA-Z0-9_:-]+)(?:\s[^>]*)?\/?>/;
     const match = text.match(startTagRegex);
 
     if (!match) return null;
 
     const startIndex = match.index;
     const rootTagName = match[1];
-
     const fullMatch = match[0];
+
     if (fullMatch.endsWith('/>')) {
         return fullMatch;
     }
 
     let balance = 0;
-
-    const tagRegex = /<\/?([a-zA-Z0-9_:-]+)(?:\s[^>]*)?\/?\>/g;
+    const tagRegex = /<\/?([a-zA-Z0-9_:-]+)(?:\s[^>]*)?\/?>/g;
     tagRegex.lastIndex = startIndex;
 
     let matchTag;
@@ -190,7 +236,7 @@ export function extractXmlFromString(text) {
         }
 
         if (balance === 0) {
-            return text.substring(startIndex, matchTag.index + fullTag.length);
+            return text.substring(startIndex, tagRegex.lastIndex);
         }
     }
 
@@ -208,25 +254,53 @@ export function extractCsvFromString(text) {
     const lines = text.split('\n');
     let startLineIndex = -1;
 
-    for (let i = 0; i < lines.length; i++) {
+    const isJsonLike = (line) => {
+        const trimmed = line.trim();
+        return /^"[^"]+"\s*:/.test(trimmed) || /^[\{\[]/.test(trimmed) || /^[\}\]],?$/.test(trimmed);
+    };
+    const isYamlLike = (line) => {
+        const trimmed = line.trim();
+        return /^- /.test(trimmed) || /^[^",]+:\s/.test(trimmed);
+    };
+    const isXmlLike = (line) => {
+        const trimmed = line.trim();
+        return trimmed.startsWith('<') && trimmed.includes('>');
+    };
+    const isToonStructure = (line) => {
+        const trimmed = line.trim();
+        return /^.*?\[\d+\].*:\s*$/.test(trimmed);
+    };
+
+    let i = 0;
+    while (i < lines.length) {
         const line = lines[i];
+
+        if (isToonStructure(line)) {
+            const countMatch = line.match(/\[(\d+)\]/);
+            const count = countMatch ? parseInt(countMatch[1], 10) : 0;
+            i += count + 1;
+            continue;
+        }
+
         const commaCount = (line.match(/,/g) || []).length;
         if (commaCount > 0) {
-            startLineIndex = i;
-            break;
+            if (!isJsonLike(line) && !isYamlLike(line) && !isXmlLike(line)) {
+                startLineIndex = i;
+                break;
+            }
         }
+        i++;
     }
 
     if (startLineIndex === -1) return null;
 
     const resultLines = [];
-
-    for (let i = startLineIndex; i < lines.length; i++) {
-        const line = lines[i];
+    for (let j = startLineIndex; j < lines.length; j++) {
+        const line = lines[j];
         if (line.trim() === '') continue;
 
         const commaCount = (line.match(/,/g) || []).length;
-        if (commaCount === 0) {
+        if (commaCount === 0 || isJsonLike(line) || isYamlLike(line) || isXmlLike(line)) {
             break;
         }
         resultLines.push(line);
@@ -234,10 +308,134 @@ export function extractCsvFromString(text) {
 
     const result = resultLines.join('\n').trim();
 
-    // Avoid matching TOON arrays (e.g. users[2]{id,name}:)
+    // Avoid matching TOON arrays
     if (/^\s*(\w+)?\[\d+\]/.test(result)) {
         return null;
     }
 
+    // Final check for JSON-like start
+    if (/^[\{\[]/.test(result)) {
+        return null;
+    }
+
+    return result;
+}
+
+/**
+ * Flattens a JSON object/list recursivey.
+ * @param {*} obj 
+ * @param {string} prefix 
+ * @param {Object} result 
+ * @returns {Object}
+ */
+export function flattenObject(obj, prefix = '', result = {}) {
+    if (obj === null || typeof obj === 'undefined') {
+        result[prefix] = null;
+        return result;
+    }
+
+    // Try parsing string if it looks like JSON
+    if (typeof obj === 'string') {
+        const trimmed = obj.trim();
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            try {
+                const parsed = JSON.parse(obj);
+                return flattenObject(parsed, prefix, result);
+            } catch (e) { }
+        }
+        result[prefix] = obj;
+        return result;
+    }
+
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            const newKey = prefix ? `${prefix}.${i}` : `${i}`;
+            flattenObject(obj[i], newKey, result);
+        }
+    } else if (typeof obj === 'object') {
+        for (const key in obj) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            flattenObject(obj[key], newKey, result);
+        }
+    } else {
+        result[prefix] = obj;
+    }
+
+    return result;
+}
+
+/**
+ * Unflattens a JSON object (reverses flattening).
+ * @param {Object} data 
+ * @returns {Object}
+ */
+export function unflattenObject(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return data;
+    }
+
+    const hasDot = Object.keys(data).some(k => k.includes('.'));
+    if (!hasDot) return data;
+
+    const result = {};
+    for (const key in data) {
+        const parts = key.split('.');
+        let current = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current)) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = data[key];
+    }
     return result;
 }
+
+/**
+ * Helper to build an XML tag string from a key and value object.
+ * @param {string} key 
+ * @param {*} value 
+ * @returns {string}
+ */
+export function buildTag(key, value) {
+    const sanitizedKey = sanitizeTagName(key);
+
+    if (value === null || typeof value === 'undefined') {
+        return `<${sanitizedKey} />`;
+    }
+
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        let attrs = '';
+        let content = '';
+
+        if (value['@attributes']) {
+            for (const k in value['@attributes']) {
+                attrs += ` ${k}="${value['@attributes'][k]}"`;
+            }
+        }
+
+        for (const k in value) {
+            if (k === '@attributes') continue;
+            if (k === '#text') {
+                content += String(value[k]);
+            } else {
+                const val = value[k];
+                if (Array.isArray(val)) {
+                    val.forEach(item => {
+                        content += buildTag(k, item);
+                    });
+                } else {
+                    content += buildTag(k, val);
+                }
+            }
+        }
+        return `<${sanitizedKey}${attrs}>${content}</${sanitizedKey}>`;
+    } else if (Array.isArray(value)) {
+        // This shouldn't happen if called correctly via parent, but for safety:
+        return value.map(item => buildTag(key, item)).join('');
+    } else {
+        return `<${sanitizedKey}>${value}</${sanitizedKey}>`;
+    }
+}

package/src/xml.js

@@ -4,7 +4,7 @@
  */
 
 import { jsonToToonSync, toonToJsonSync } from './json.js';
-import { encodeXmlReservedChars, extractXmlFromString } from './utils.js';
+import { encodeXmlReservedChars, extractXmlFromString, buildTag } from './utils.js';
 
 /**
  * Converts XML DOM to JSON object
@@ -31,6 +31,10 @@ function xmlToJsonObject(xml) {
         for (let i = 0; i < xml.childNodes.length; i++) {
             const item = xml.childNodes.item(i);
             const nodeName = item.nodeName;
+
+            // Skip comment nodes
+            if (item.nodeType === 8) continue;
+
             const childJson = xmlToJsonObject(item);
 
             if (childJson === undefined) continue;
@@ -38,8 +42,7 @@ function xmlToJsonObject(xml) {
             if (obj[nodeName] === undefined) {
                 obj[nodeName] = childJson;
             } else {
-                // Handle multiple children with the same tag name (create an array)
-                if (typeof obj[nodeName].push === "undefined") {
+                if (!Array.isArray(obj[nodeName])) {
                     const old = obj[nodeName];
                     obj[nodeName] = [];
                     obj[nodeName].push(old);
@@ -49,71 +52,15 @@ function xmlToJsonObject(xml) {
         }
     }
 
-    // Clean up: If the object only contains text and no attributes/children, return the text directly
-    if (Object.keys(obj).length === 1 && obj['#text'] !== undefined) {
+    // Special case: if object only has #text and no attributes/children, return text directly
+    const keys = Object.keys(obj);
+    if (keys.length === 1 && keys[0] === '#text' && !obj['@attributes']) {
         return obj['#text'];
     }
 
     return obj;
 }
 
-/**
- * Converts JSON object to XML string
- * @param {Object} obj - JSON object
- * @returns {string} XML string
- */
-function jsonObjectToXml(obj) {
-    let xml = '';
-
-    for (const key in obj) {
-        if (!obj.hasOwnProperty(key)) continue;
-
-        const value = obj[key];
-
-        if (key === "#text") {
-            // Handle text content directly
-            xml += value;
-        }
-        else if (key === '@attributes' && typeof value === 'object') {
-            // Handle attributes: Convert { "@attributes": { "id": "1" } } to id="1"
-            let attrString = '';
-            for (const attrKey in value) {
-                attrString += ` ${attrKey}="${value[attrKey]}"`;
-            }
-            xml += attrString;
-        }
-        else if (Array.isArray(value)) {
-            // Handle arrays: Loop and create a tag for each item
-            value.forEach(item => {
-                if (typeof item === 'object') {
-                    const innerContent = jsonObjectToXml(item);
-                    const attrMatch = innerContent.match(/^(\s+[^\s=]+="[^"]*")*/);
-                    const attrs = attrMatch ? attrMatch[0] : "";
-                    const body = innerContent.slice(attrs.length);
-
-                    xml += `<${key}${attrs}>${body}</${key}>`;
-                } else {
-                    xml += `<${key}>${item}</${key}>`;
-                }
-            });
-        }
-        else if (typeof value === 'object' && value !== null) {
-            // Handle nested objects: Recurse and wrap in the current key's tag
-            const innerContent = jsonObjectToXml(value);
-            const attrMatch = innerContent.match(/^(\s+[^\s=]+="[^"]*")*/);
-            const attrs = attrMatch ? attrMatch[0] : "";
-            const body = innerContent.slice(attrs.length);
-
-            xml += `<${key}${attrs}>${body}</${key}>`;
-        }
-        else if (value !== null && value !== undefined) {
-            // Handle primitive values: Create a simple tag
-            xml += `<${key}>${value}</${key}>`;
-        }
-    }
-    return xml;
-}
-
 /**
  * Internal core function to convert pure XML string to TOON (Sync)
  * @param {string} xmlString 
@@ -134,21 +81,17 @@ function parseXmlToToonSync(xmlString) {
         'application/xml'
     );
 
-    // Check for parser errors (works in both browser and xmldom)
-    if (xmlDoc.querySelector) {
-        // Browser environment
-        const parserError = xmlDoc.querySelector('parsererror');
-        if (parserError) {
-            throw new Error(parserError.textContent);
-        }
-    } else {
-        // xmldom environment - check documentElement
-        if (xmlDoc.documentElement && xmlDoc.documentElement.nodeName === 'parsererror') {
-            throw new Error(xmlDoc.documentElement.textContent || 'XML parsing error');
-        }
+    const parserError = xmlDoc.querySelector ? xmlDoc.querySelector('parsererror') :
+        (xmlDoc.documentElement && xmlDoc.documentElement.nodeName === 'parsererror' ? xmlDoc.documentElement : null);
+
+    if (parserError) {
+        throw new Error(parserError.textContent || 'XML parsing error');
     }
 
-    const jsonObject = xmlToJsonObject(xmlDoc);
+    const rootElement = xmlDoc.documentElement;
+    const jsonObject = {};
+    jsonObject[rootElement.nodeName] = xmlToJsonObject(rootElement);
+
     return jsonToToonSync(jsonObject);
 }
 
@@ -194,9 +137,7 @@ export async function xmlToToon(xmlString) {
         try {
             const { DOMParser: NodeDOMParser } = await import('xmldom');
             global.DOMParser = NodeDOMParser;
-        } catch (e) {
-            // Ignore if import fails, xmlToToonSync will throw appropriate error
-        }
+        } catch (e) { }
     }
     return xmlToToonSync(xmlString);
 }
@@ -213,7 +154,11 @@ export function toonToXmlSync(toonString) {
     }
 
     const jsonObject = toonToJsonSync(toonString);
-    return jsonObjectToXml(jsonObject);
+    let xml = "";
+    for (const k in jsonObject) {
+        xml += buildTag(k, jsonObject[k]);
+    }
+    return xml;
 }
 
 /**