toon-formatter 1.0.2 → 1.1.0

package/src/csv.js

@@ -3,19 +3,15 @@
  */
 
 import Papa from 'papaparse';
-import { jsonToToon, toonToJson } from './json.js';
+import { jsonToToonSync, toonToJsonSync } from './json.js';
+import { extractCsvFromString } from './utils.js';
 
 /**
- * Converts CSV to TOON format
- * @param {string} csvString - CSV formatted string
- * @returns {Promise<string>} TOON formatted string
- * @throws {Error} If CSV is invalid
+ * Internal core function to convert pure CSV string to TOON (Async)
+ * @param {string} csvString 
+ * @returns {Promise<string>}
  */
-export function csvToToon(csvString) {
-    if (!csvString || typeof csvString !== 'string') {
-        throw new Error('Input must be a non-empty string');
-    }
-
+function parseCsvToToon(csvString) {
     return new Promise((resolve, reject) => {
         Papa.parse(csvString, {
             header: true,
@@ -28,7 +24,7 @@ export function csvToToon(csvString) {
                         throw new Error("CSV parsing failed — cannot convert.");
                     }
 
-                    const toonString = jsonToToon(jsonObject);
+                    const toonString = jsonToToonSync(jsonObject);
                     resolve(toonString);
                 } catch (error) {
                     reject(error);
@@ -42,16 +38,11 @@ export function csvToToon(csvString) {
 }
 
 /**
- * Converts CSV to TOON format (synchronous version)
- * @param {string} csvString - CSV formatted string
- * @returns {string} TOON formatted string
- * @throws {Error} If CSV is invalid
+ * Internal core function to convert pure CSV string to TOON (Sync)
+ * @param {string} csvString 
+ * @returns {string}
  */
-export function csvToToonSync(csvString) {
-    if (!csvString || typeof csvString !== 'string') {
-        throw new Error('Input must be a non-empty string');
-    }
-
+function parseCsvToToonSync(csvString) {
     const results = Papa.parse(csvString, {
         header: true,
         dynamicTyping: true,
@@ -67,21 +58,63 @@ export function csvToToonSync(csvString) {
         throw new Error("CSV parsing failed — cannot convert.");
     }
 
-    return jsonToToon(jsonObject);
+    return jsonToToonSync(jsonObject);
+}
+
+/**
+ * Converts CSV (or mixed text with CSV) to TOON format (Async)
+ * @param {string} csvString - CSV formatted string or mixed text
+ * @returns {Promise<string>} TOON formatted string
+ * @throws {Error} If CSV is invalid
+ */
+export async function csvToToon(csvString) {
+    return csvToToonSync(csvString);
 }
 
 /**
- * Converts TOON to CSV format
+ * Converts CSV (or mixed text with CSV) to TOON format (synchronous version)
+ * @param {string} csvString - CSV formatted string or mixed text
+ * @returns {string} TOON formatted string
+ * @throws {Error} If CSV is invalid
+ */
+export function csvToToonSync(csvString) {
+    if (!csvString || typeof csvString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+
+    let convertedText = csvString;
+    let iterationCount = 0;
+    const maxIterations = 100;
+
+    while (iterationCount < maxIterations) {
+        const csvBlock = extractCsvFromString(convertedText);
+        if (!csvBlock) break;
+
+        try {
+            const toonString = parseCsvToToonSync(csvBlock);
+            const toonOutput = toonString.trim();
+            convertedText = convertedText.replace(csvBlock, toonOutput);
+            iterationCount++;
+        } catch (e) {
+            break;
+        }
+    }
+
+    return convertedText;
+}
+
+/**
+ * Converts TOON to CSV format (Synchronous)
  * @param {string} toonString - TOON formatted string
  * @returns {string} CSV formatted string
  * @throws {Error} If TOON is invalid
  */
-export function toonToCsv(toonString) {
+export function toonToCsvSync(toonString) {
     if (!toonString || typeof toonString !== 'string') {
         throw new Error('Input must be a non-empty string');
     }
 
-    const jsonObject = toonToJson(toonString);
+    const jsonObject = toonToJsonSync(toonString);
 
     const csvString = Papa.unparse(jsonObject, {
         header: true,
@@ -90,3 +123,12 @@ export function toonToCsv(toonString) {
 
     return csvString;
 }
+
+/**
+ * Converts TOON to CSV format (Async)
+ * @param {string} toonString - TOON formatted string
+ * @returns {Promise<string>} CSV formatted string
+ */
+export async function toonToCsv(toonString) {
+    return toonToCsvSync(toonString);
+}

package/src/index.js

@@ -6,24 +6,33 @@
  * 
  * Reduce LLM token costs by up to 40% using TOON format.
  * 
- * @module toon-converter
+ * @module toon-formatter
  */
 
-import { jsonToToon, toonToJson } from './json.js';
-import { yamlToToon, toonToYaml } from './yaml.js';
-import { xmlToToon, toonToXml } from './xml.js';
-import { csvToToon, csvToToonSync, toonToCsv } from './csv.js';
-import { validateToonString } from './validator.js';
-import { encodeXmlReservedChars, splitByDelimiter, parseValue, formatValue } from './utils.js';
+import { jsonToToonSync, jsonToToon, toonToJsonSync, toonToJson } from './json.js';
+import { yamlToToonSync, yamlToToon, toonToYamlSync, toonToYaml } from './yaml.js';
+import { xmlToToonSync, xmlToToon, toonToXmlSync, toonToXml } from './xml.js';
+import { csvToToonSync, csvToToon, toonToCsvSync, toonToCsv } from './csv.js';
+import { validateToonString, validateToonStringSync } from './validator.js';
+import {
+    encodeXmlReservedChars,
+    splitByDelimiter,
+    parseValue,
+    formatValue,
+    extractJsonFromString,
+    extractXmlFromString,
+    extractCsvFromString
+} from './utils.js';
 
 // Exports
 export {
-    jsonToToon, toonToJson,
-    yamlToToon, toonToYaml,
-    xmlToToon, toonToXml,
-    csvToToon, csvToToonSync, toonToCsv,
-    validateToonString,
-    encodeXmlReservedChars, splitByDelimiter, parseValue, formatValue
+    jsonToToonSync, jsonToToon, toonToJsonSync, toonToJson,
+    yamlToToonSync, yamlToToon, toonToYamlSync, toonToYaml,
+    xmlToToonSync, xmlToToon, toonToXmlSync, toonToXml,
+    csvToToonSync, csvToToon, toonToCsvSync, toonToCsv,
+    validateToonString, validateToonStringSync,
+    encodeXmlReservedChars, splitByDelimiter, parseValue, formatValue,
+    extractJsonFromString, extractXmlFromString, extractCsvFromString
 };
 
 /**
@@ -31,56 +40,110 @@ export {
  */
 export class ToonConverter {
     /**
-     * Convert JSON to TOON
+     * Convert JSON to TOON (Sync)
      * @param {*} jsonData - JSON data (object, array, or primitive)
      * @returns {string} TOON formatted string
      */
     static fromJson(jsonData) {
+        return jsonToToonSync(jsonData);
+    }
+
+    /**
+     * Convert JSON to TOON (Async)
+     * @param {*} jsonData - JSON data
+     * @returns {Promise<string>} TOON formatted string
+     */
+    static async fromJsonAsync(jsonData) {
         return jsonToToon(jsonData);
     }
 
     /**
-     * Convert TOON to JSON
+     * Convert TOON to JSON (Sync)
      * @param {string} toonString - TOON formatted string
      * @returns {*} Parsed JSON data
      */
     static toJson(toonString) {
+        return toonToJsonSync(toonString);
+    }
+
+    /**
+     * Convert TOON to JSON (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {Promise<*>} Parsed JSON data
+     */
+    static async toJsonAsync(toonString) {
         return toonToJson(toonString);
     }
 
     /**
-     * Convert YAML to TOON
+     * Convert YAML to TOON (Sync)
      * @param {string} yamlString - YAML formatted string
      * @returns {string} TOON formatted string
      */
     static fromYaml(yamlString) {
+        return yamlToToonSync(yamlString);
+    }
+
+    /**
+     * Convert YAML to TOON (Async)
+     * @param {string} yamlString - YAML formatted string
+     * @returns {Promise<string>} TOON formatted string
+     */
+    static async fromYamlAsync(yamlString) {
         return yamlToToon(yamlString);
     }
 
     /**
-     * Convert TOON to YAML
+     * Convert TOON to YAML (Sync)
      * @param {string} toonString - TOON formatted string
      * @returns {string} YAML formatted string
      */
     static toYaml(toonString) {
+        return toonToYamlSync(toonString);
+    }
+
+    /**
+     * Convert TOON to YAML (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {Promise<string>} YAML formatted string
+     */
+    static async toYamlAsync(toonString) {
         return toonToYaml(toonString);
     }
 
+    /**
+     * Convert XML to TOON (Sync)
+     * @param {string} xmlString - XML formatted string
+     * @returns {string} TOON formatted string
+     */
+    static fromXml(xmlString) {
+        return xmlToToonSync(xmlString);
+    }
+
     /**
      * Convert XML to TOON (Async)
      * @param {string} xmlString - XML formatted string
      * @returns {Promise<string>} TOON formatted string
      */
-    static async fromXml(xmlString) {
+    static async fromXmlAsync(xmlString) {
         return xmlToToon(xmlString);
     }
 
     /**
-     * Convert TOON to XML
+     * Convert TOON to XML (Sync)
      * @param {string} toonString - TOON formatted string
      * @returns {string} XML formatted string
      */
     static toXml(toonString) {
+        return toonToXmlSync(toonString);
+    }
+
+    /**
+     * Convert TOON to XML (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {Promise<string>} XML formatted string
+     */
+    static async toXmlAsync(toonString) {
         return toonToXml(toonString);
     }
 
@@ -89,7 +152,7 @@ export class ToonConverter {
      * @param {string} csvString - CSV formatted string
      * @returns {Promise<string>} TOON formatted string
      */
-    static async fromCsv(csvString) {
+    static async fromCsvAsync(csvString) {
         return csvToToon(csvString);
     }
 
@@ -98,16 +161,25 @@ export class ToonConverter {
      * @param {string} csvString - CSV formatted string
      * @returns {string} TOON formatted string
      */
-    static fromCsvSync(csvString) {
+    static fromCsv(csvString) {
         return csvToToonSync(csvString);
     }
 
     /**
-     * Convert TOON to CSV
+     * Convert TOON to CSV (Sync)
      * @param {string} toonString - TOON formatted string
      * @returns {string} CSV formatted string
      */
     static toCsv(toonString) {
+        return toonToCsvSync(toonString);
+    }
+
+    /**
+     * Convert TOON to CSV (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {Promise<string>} CSV formatted string
+     */
+    static async toCsvAsync(toonString) {
         return toonToCsv(toonString);
     }
 
@@ -117,6 +189,15 @@ export class ToonConverter {
      * @returns {{isValid: boolean, error: string|null}} Validation result
      */
     static validate(toonString) {
+        return validateToonStringSync(toonString);
+    }
+
+    /**
+     * Validate a TOON string (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {{isValid: boolean, error: string|null}} Validation result
+     */
+    static async validateAsync(toonString) {
         return validateToonString(toonString);
     }
 }

package/src/json.js

@@ -2,16 +2,41 @@
  * JSON ↔ TOON Converter
  */
 
-import { formatValue, parseValue, splitByDelimiter } from './utils.js';
+import { formatValue, parseValue, splitByDelimiter, extractJsonFromString } from './utils.js';
+import { validateToonStringSync } from './validator.js';
 
 /**
- * Converts JSON to TOON format
+ * Converts JSON to TOON format (Synchronous)
  * @param {*} data - JSON data to convert
  * @param {string} key - Current key name (for recursion)
  * @param {number} depth - Current indentation depth
  * @returns {string} TOON formatted string
  */
-export function jsonToToon(data, key = '', depth = 0) {
+export function jsonToToonSync(data, key = '', depth = 0) {
+    // Handle String Input (Potential JSON string or Mixed Text)
+    if (typeof data === 'string' && key === '' && depth === 0) {
+        let convertedText = data;
+        let iterationCount = 0;
+        const maxIterations = 100;
+
+        while (iterationCount < maxIterations) {
+            const jsonString = extractJsonFromString(convertedText);
+            if (!jsonString) break;
+
+            try {
+                const jsonObject = JSON.parse(jsonString);
+                // Recursively call jsonToToonSync with the object
+                const toonString = jsonToToonSync(jsonObject);
+                const toonOutput = toonString.trim();
+                convertedText = convertedText.replace(jsonString, toonOutput);
+                iterationCount++;
+            } catch (e) {
+                break;
+            }
+        }
+        return convertedText;
+    }
+
     const indent = '  '.repeat(depth);
     const nextIndent = '  '.repeat(depth + 1);
 
@@ -61,44 +86,50 @@ export function jsonToToon(data, key = '', depth = 0) {
             return lines.join('\n');
         }
 
-        // ---- YAML-STYLE ARRAY (nested objects present) ----
+        // ---- STANDARD ARRAY OF OBJECTS ----
         const lines = [];
         lines.push(`${indent}${key}[${length}]:`);
-
-        data.forEach(row => {
-            lines.push(`${nextIndent}-`); // item marker
-            for (const f of fields) {
-                const child = row[f];
-                const block = jsonToToon(child, f, depth + 2);
-                lines.push(block);
-            }
+        data.forEach(item => {
+            lines.push(jsonToToonSync(item, '', depth + 1));
         });
-
         return lines.join('\n');
     }
 
     // ---- Object ----
     const lines = [];
-
-    if (key) lines.push(`${indent}${key}:`);
-
-    for (const childKey in data) {
-        if (Object.prototype.hasOwnProperty.call(data, childKey)) {
-            const child = data[childKey];
-            const block = jsonToToon(child, childKey, depth + 1);
-            lines.push(block);
-        }
+    if (key) {
+        lines.push(`${indent}${key}:`);
     }
 
+    Object.keys(data).forEach(k => {
+        lines.push(jsonToToonSync(data[k], k, key ? depth + 1 : depth));
+    });
+
     return lines.join('\n');
 }
 
 /**
- * Converts TOON to JSON format
+ * Converts JSON to TOON format (Async)
+ * @param {*} data - JSON data to convert
+ * @returns {Promise<string>} TOON formatted string
+ */
+export async function jsonToToon(data) {
+    return jsonToToonSync(data);
+}
+
+/**
+ * Converts TOON to JSON format (Synchronous)
  * @param {string} toonString - TOON formatted string
- * @returns {*} Parsed JSON data
+ * @returns {Object} JSON object
+ * @throws {Error} If TOON string is invalid
  */
-export function toonToJson(toonString) {
+export function toonToJsonSync(toonString) {
+    // Validate TOON string before conversion
+    const validationStatus = validateToonStringSync(toonString);
+    if (!validationStatus.isValid) {
+        throw new Error(`Invalid TOON: ${validationStatus.error}`);
+    }
+
     const lines = toonString.split('\n');
     let root = {};
     let stack = [];
@@ -295,3 +326,12 @@ export function toonToJson(toonString) {
 
     return root;
 }
+
+/**
+ * Converts TOON to JSON format (Async)
+ * @param {string} toonString - TOON formatted string
+ * @returns {Promise<Object>} Parsed JSON data
+ */
+export async function toonToJson(toonString) {
+    return toonToJsonSync(toonString);
+}

package/src/utils.js

@@ -79,3 +79,158 @@ export function formatValue(v) {
     if (typeof v === "string") return `"${v.replace(/"/g, '\\"')}"`;
     return v; // number, boolean
 }
+
+/**
+ * Extracts JSON from mixed text
+ * @param {string} text - Text containing JSON
+ * @returns {string|null} Extracted JSON string or null
+ */
+export function extractJsonFromString(text) {
+    if (!text || typeof text !== 'string') return null;
+
+    let startIndex = -1;
+
+    // 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;
+            }
+            startIndex = i;
+            break;
+        }
+    }
+
+    if (startIndex === -1) return null;
+
+    let balance = 0;
+    let inQuote = false;
+    let escape = false;
+
+    for (let i = startIndex; i < text.length; i++) {
+        const char = text[i];
+
+        if (escape) {
+            escape = false;
+            continue;
+        }
+
+        if (char === '\\') {
+            escape = true;
+            continue;
+        }
+
+        if (char === '"') {
+            inQuote = !inQuote;
+            continue;
+        }
+
+        if (!inQuote) {
+            if (char === '{' || char === '[') {
+                balance++;
+            } else if (char === '}' || char === ']') {
+                balance--;
+            }
+
+            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
+                }
+            }
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Extracts XML from mixed text
+ * @param {string} text - Text containing XML
+ * @returns {string|null} Extracted XML string or null
+ */
+export function extractXmlFromString(text) {
+    if (!text || typeof text !== 'string') return null;
+
+    // Find first start tag
+    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;
+    tagRegex.lastIndex = startIndex;
+
+    let matchTag;
+    while ((matchTag = tagRegex.exec(text)) !== null) {
+        const fullTag = matchTag[0];
+        const tagName = matchTag[1];
+
+        if (tagName !== rootTagName) continue;
+
+        if (fullTag.startsWith('</')) {
+            balance--;
+        } else if (!fullTag.endsWith('/>')) {
+            balance++;
+        }
+
+        if (balance === 0) {
+            return text.substring(startIndex, matchTag.index + fullTag.length);
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Extracts CSV from mixed text
+ * @param {string} text - Text containing CSV
+ * @returns {string|null} Extracted CSV string or null
+ */
+export function extractCsvFromString(text) {
+    if (!text || typeof text !== 'string') return null;
+
+    const lines = text.split('\n');
+    let startLineIndex = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const commaCount = (line.match(/,/g) || []).length;
+        if (commaCount > 0) {
+            startLineIndex = i;
+            break;
+        }
+    }
+
+    if (startLineIndex === -1) return null;
+
+    const resultLines = [];
+
+    for (let i = startLineIndex; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === '') continue;
+
+        const commaCount = (line.match(/,/g) || []).length;
+        if (commaCount === 0) {
+            break;
+        }
+        resultLines.push(line);
+    }
+
+    return resultLines.join('\n').trim();
+}