toon-formatter 1.0.2 → 1.1.0

package/src/validator.js

@@ -1,28 +1,28 @@
 /**
- * TOON String Validator
+ * TOON String Validator (Enhanced)
  */
 
 import { splitByDelimiter } from './utils.js';
 
 /**
- * Validates a TOON string for syntax and structural correctness
+ * Validates a TOON string for syntax and structural correctness (Synchronous)
  * @param {string} toonString - TOON string to validate
  * @returns {{isValid: boolean, error: string|null}} Validation result
  */
-export function validateToonString(toonString) {
+export function validateToonStringSync(toonString) {
     if (!toonString || typeof toonString !== 'string') {
         return { isValid: false, error: 'Input must be a non-empty string.' };
     }
 
     const lines = toonString.split('\n');
-    // Stack of contexts: { indent, type: 'root'|'object'|'array', expected?, count? }
+    // Stack of contexts: { indent, type: 'root'|'object'|'array', expected?, count?, isTabular? }
     const contextStack = [{ indent: 0, type: 'root', count: 0 }];
     let lineNumber = 0;
 
     // Regex Definitions (based on TOON Rules)
     const REGEX = {
         mapKey: /^[^:\[]+:\s*$/,
-        arrayKey: /^[^:]+\[(\d+)([\t|])?\](?:\{[^}]+\})?:\s*(.*)$/, // Capture N, delimiter, content
+        arrayKey: /^[^:\[]+\[(\d+)([\t|])?\](?:\{[^}]+\})?:\s*(.*)$/, // Capture N, delimiter, content
         rootArray: /^\[(\d+)([\t|])?\](?:\{[^}]+\})?:\s*(.*)$/,    // Capture N, delimiter, content
         listItem: /^\-.*/,
         listItemEmpty: /^\-\s*$/,
@@ -54,9 +54,30 @@ export function validateToonString(toonString) {
 
         const trimmedLine = line.trim();
         const currentIndent = rawLine.search(/\S|$/);
-        const currentContext = contextStack[contextStack.length - 1];
+        let currentContext = contextStack[contextStack.length - 1];
         const requiredIndent = currentContext.indent;
 
+        // --- Strict Check for Empty Blocks ---
+        // If the previous line opened a block (like an array) but we didn't indent,
+        // and it wasn't an inline array, then it's an empty block.
+        // If the array expects items (size > 0), this is an error.
+        if (lineNumber > 1) {
+            const prevLineRaw = lines[lineNumber - 2];
+            const prevLineTrimmed = prevLineRaw.trim();
+            const arrMatch = prevLineTrimmed.match(REGEX.arrayKey) || prevLineTrimmed.match(REGEX.rootArray);
+
+            if (arrMatch && currentIndent <= requiredIndent) {
+                // It was an array declaration, and we are NOT inside it (no indent increase).
+                const size = parseInt(arrMatch[1], 10);
+                const content = arrMatch[3];
+
+                // If no inline content and size > 0, it's a missing block.
+                if ((!content || content.trim() === '') && size > 0) {
+                    return { isValid: false, error: `L${lineNumber - 1}: Array declared with size ${size} but has no items (expected indented block).` };
+                }
+            }
+        }
+
         // --- Inline Array Validation ---
         let arrayMatch = trimmedLine.match(REGEX.arrayKey) || trimmedLine.match(REGEX.rootArray);
         if (arrayMatch) {
@@ -78,6 +99,7 @@ export function validateToonString(toonString) {
                 }
             } else {
                 // Block Array start. 
+                // If it's Root Array at indent 0, update root context.
                 if (trimmedLine.match(REGEX.rootArray) && contextStack.length === 1) {
                     contextStack[0].type = 'array';
                     contextStack[0].expected = size;
@@ -88,14 +110,17 @@ export function validateToonString(toonString) {
 
         // --- State Management (Tabular) ---
         if (isInsideTabularArray) {
+            // For tabular arrays, accept any indent >= root indent after the header
             const rootContext = contextStack[0];
             if (currentIndent >= rootContext.indent || (rootContext.indent === 0 && currentIndent > 0)) {
                 if (trimmedLine.includes(':') && !trimmedLine.startsWith('"')) {
                     return { isValid: false, error: `L${lineNumber}: Tabular rows cannot contain a colon.` };
                 }
+                // Count tabular row as item
                 if (rootContext.type === 'array') {
                     rootContext.count++;
                 }
+                // Update root indent if this is first data row
                 if (rootContext.indent === 0) {
                     rootContext.indent = currentIndent;
                 }
@@ -113,30 +138,43 @@ export function validateToonString(toonString) {
                 return { isValid: false, error: `L${lineNumber}: Indentation error.` };
             }
 
+            // Determine context type
             let newContext = { indent: currentIndent, type: 'object' };
 
             const prevArrayMatch = prevLineTrimmed.match(REGEX.arrayKey) || prevLineTrimmed.match(REGEX.rootArray);
             if (prevArrayMatch) {
+                // Check if this is a root array that was already initialized
                 const isRootArrayAlreadySet = prevLineTrimmed.match(REGEX.rootArray) &&
                     contextStack.length === 1 &&
                     contextStack[0].type === 'array';
 
+                const isTabular = prevLineTrimmed.includes('{') && prevLineTrimmed.includes('}');
+
                 if (!isRootArrayAlreadySet) {
+                    // Create new array context for non-root arrays
                     const size = parseInt(prevArrayMatch[1], 10);
-                    newContext = { indent: currentIndent, type: 'array', expected: size, count: 0 };
+                    newContext = { indent: currentIndent, type: 'array', expected: size, count: 0, isTabular: isTabular };
                     contextStack.push(newContext);
+                } else {
+                    // For root arrays, update the existing context
+                    contextStack[0].isTabular = isTabular;
                 }
             } else {
                 contextStack.push(newContext);
             }
 
+            // Update root array indent if this is the first indented item
             if (contextStack.length === 1 && contextStack[0].type === 'array' && contextStack[0].indent === 0) {
                 contextStack[0].indent = currentIndent;
             }
 
+            // Count the current line if it's a list item in an array
             const targetContext = contextStack[contextStack.length - 1];
             if (targetContext.type === 'array') {
-                if (trimmedLine.match(REGEX.listItem)) {
+                if (targetContext.isTabular) {
+                    // Tabular items don't need dash
+                    targetContext.count++;
+                } else if (trimmedLine.match(REGEX.listItem)) {
                     targetContext.count++;
                 }
             }
@@ -145,9 +183,11 @@ export function validateToonString(toonString) {
             // Un-indentation
             let foundMatch = false;
 
+            // Pop and Validate
             while (contextStack.length > 1) {
                 const popped = contextStack.pop();
 
+                // Validate Array Size on Close
                 if (popped.type === 'array') {
                     if (popped.count !== popped.expected) {
                         return { isValid: false, error: `Array size mismatch. Declared ${popped.expected}, found ${popped.count} items (ending around L${lineNumber}).` };
@@ -164,28 +204,41 @@ export function validateToonString(toonString) {
                 return { isValid: false, error: `L${lineNumber}: Invalid un-indentation.` };
             }
 
+            // After popping, count items in parent context if it's an array
             const parentContext = contextStack[contextStack.length - 1];
             if (parentContext.type === 'array') {
-                if (trimmedLine.match(REGEX.listItem)) {
+                if (parentContext.isTabular) {
+                    parentContext.count++;
+                } else if (trimmedLine.match(REGEX.listItem)) {
                     parentContext.count++;
                 }
             }
 
         } else {
             // Same Indent
+            // If array, count items
             if (currentContext.type === 'array') {
-                if (trimmedLine.match(REGEX.listItem)) {
+                if (currentContext.isTabular) {
+                    currentContext.count++;
+                } else if (trimmedLine.match(REGEX.listItem)) {
                     currentContext.count++;
                 }
             }
         }
 
+        // Update currentContext as it might have changed (push/pop)
+        currentContext = contextStack[contextStack.length - 1];
+
         // --- Syntax Check ---
         if (trimmedLine.match(REGEX.arrayKey) || trimmedLine.match(REGEX.rootArray)) {
             if (startsTabular(trimmedLine)) isInsideTabularArray = true;
         }
         else if (trimmedLine.match(REGEX.mapKey)) { }
-        else if (trimmedLine.match(REGEX.listItem)) { }
+        else if (trimmedLine.match(REGEX.listItem)) {
+            if (currentContext.type !== 'array') {
+                return { isValid: false, error: `L${lineNumber}: List item found in non-array context.` };
+            }
+        }
         else if (trimmedLine.includes(':')) {
             if (!trimmedLine.match(REGEX.keyValue)) {
                 return { isValid: false, error: `L${lineNumber}: Invalid Key-Value assignment.` };
@@ -216,3 +269,12 @@ export function validateToonString(toonString) {
 
     return { isValid: true, error: null };
 }
+
+/**
+ * Validates a TOON string for syntax and structural correctness (Async)
+ * @param {string} toonString - TOON string to validate
+ * @returns {{isValid: boolean, error: string|null}} Validation result
+ */
+export async function validateToonString(toonString) {
+    return validateToonStringSync(toonString);
+}

package/src/xml.js

@@ -3,8 +3,8 @@
  * Note: This module is designed for Node.js environments
  */
 
-import { jsonToToon, toonToJson } from './json.js';
-import { encodeXmlReservedChars } from './utils.js';
+import { jsonToToonSync, toonToJsonSync } from './json.js';
+import { encodeXmlReservedChars, extractXmlFromString } from './utils.js';
 
 /**
  * Converts XML DOM to JSON object
@@ -115,60 +115,112 @@ function jsonObjectToXml(obj) {
 }
 
 /**
- * Converts XML to TOON format (Browser environment)
- * @param {string} xmlString - XML formatted string
- * @returns {string} TOON formatted string
- * @throws {Error} If XML is invalid or DOMParser is not available
+ * Internal core function to convert pure XML string to TOON (Sync)
+ * @param {string} xmlString 
+ * @returns {string}
  */
-export async function xmlToToon(xmlString) {
-    if (!xmlString || typeof xmlString !== 'string') {
-        throw new Error('Input must be a non-empty string');
-    }
+function parseXmlToToonSync(xmlString) {
+    let Parser;
 
-    // Check if we're in a browser environment
     if (typeof DOMParser !== 'undefined') {
-        const parser = new DOMParser();
-        const xmlDoc = parser.parseFromString(
-            encodeXmlReservedChars(xmlString),
-            'application/xml'
-        );
+        Parser = DOMParser;
+    } else {
+        throw new Error('DOMParser is not available. For synchronous XML conversion in Node.js, please use the async version `xmlToToon` or polyfill global.DOMParser.');
+    }
+
+    const parser = new Parser();
+    const xmlDoc = parser.parseFromString(
+        encodeXmlReservedChars(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 jsonObject = xmlToJsonObject(xmlDoc);
+    return jsonToToonSync(jsonObject);
+}
+
+/**
+ * Converts XML (or mixed text with XML) to TOON format (Synchronous)
+ * @param {string} xmlString - XML formatted string or mixed text
+ * @returns {string} TOON formatted string
+ * @throws {Error} If XML is invalid or DOMParser is not available
+ */
+export function xmlToToonSync(xmlString) {
+    if (!xmlString || typeof xmlString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
 
-        const jsonObject = xmlToJsonObject(xmlDoc);
-        return jsonToToon(jsonObject);
+    let convertedText = xmlString;
+    let iterationCount = 0;
+    const maxIterations = 100;
+
+    while (iterationCount < maxIterations) {
+        const xmlBlock = extractXmlFromString(convertedText);
+        if (!xmlBlock) break;
+
+        try {
+            const toonString = parseXmlToToonSync(xmlBlock);
+            const toonOutput = toonString.trim();
+            convertedText = convertedText.replace(xmlBlock, toonOutput);
+            iterationCount++;
+        } catch (e) {
+            break;
+        }
     }
 
-    // Node.js environment - require xmldom
-    try {
-        const { DOMParser: NodeDOMParser } = await import('xmldom');
-        const parser = new NodeDOMParser();
-        const xmlDoc = parser.parseFromString(
-            encodeXmlReservedChars(xmlString),
-            'application/xml'
-        );
-
-        const jsonObject = xmlToJsonObject(xmlDoc);
-        return jsonToToon(jsonObject);
-    } catch (error) {
-        throw new Error('XML parsing requires DOMParser (browser) or xmldom package (Node.js). Install xmldom: npm install xmldom');
+    return convertedText;
+}
+
+/**
+ * Converts XML (or mixed text with XML) to TOON format (Async)
+ * @param {string} xmlString - XML formatted string or mixed text
+ * @returns {Promise<string>} TOON formatted string
+ */
+export async function xmlToToon(xmlString) {
+    if (typeof DOMParser === 'undefined') {
+        try {
+            const { DOMParser: NodeDOMParser } = await import('xmldom');
+            global.DOMParser = NodeDOMParser;
+        } catch (e) {
+            // Ignore if import fails, xmlToToonSync will throw appropriate error
+        }
     }
+    return xmlToToonSync(xmlString);
 }
 
 /**
- * Converts TOON to XML format
+ * Converts TOON to XML format (Synchronous)
  * @param {string} toonString - TOON formatted string
  * @returns {string} XML formatted string
  * @throws {Error} If TOON is invalid
  */
-export function toonToXml(toonString) {
+export function toonToXmlSync(toonString) {
     if (!toonString || typeof toonString !== 'string') {
         throw new Error('Input must be a non-empty string');
     }
 
-    const jsonObject = toonToJson(toonString);
+    const jsonObject = toonToJsonSync(toonString);
     return jsonObjectToXml(jsonObject);
 }
+
+/**
+ * Converts TOON to XML format (Async)
+ * @param {string} toonString - TOON formatted string
+ * @returns {Promise<string>} XML formatted string
+ */
+export async function toonToXml(toonString) {
+    return toonToXmlSync(toonString);
+}

package/src/yaml.js

@@ -3,15 +3,16 @@
  */
 
 import yaml from 'js-yaml';
-import { jsonToToon, toonToJson } from './json.js';
+import { jsonToToonSync, toonToJsonSync } from './json.js';
+
 
 /**
- * Converts YAML to TOON format
- * @param {string} yamlString - YAML formatted string
+ * Converts YAML (or mixed text with YAML) to TOON format (Synchronous)
+ * @param {string} yamlString - YAML formatted string or mixed text
  * @returns {string} TOON formatted string
  * @throws {Error} If YAML is invalid
  */
-export function yamlToToon(yamlString) {
+export function yamlToToonSync(yamlString) {
     if (!yamlString || typeof yamlString !== 'string') {
         throw new Error('Input must be a non-empty string');
     }
@@ -22,20 +23,38 @@ export function yamlToToon(yamlString) {
         throw new Error("YAML parsing failed — cannot convert.");
     }
 
-    return jsonToToon(jsonObject);
+    return jsonToToonSync(jsonObject);
+}
+
+/**
+ * Converts YAML (or mixed text with YAML) to TOON format (Async)
+ * @param {string} yamlString - YAML formatted string or mixed text
+ * @returns {Promise<string>} TOON formatted string
+ */
+export async function yamlToToon(yamlString) {
+    return yamlToToonSync(yamlString);
 }
 
 /**
- * Converts TOON to YAML format
+ * Converts TOON to YAML format (Synchronous)
  * @param {string} toonString - TOON formatted string
  * @returns {string} YAML formatted string
  * @throws {Error} If TOON is invalid
  */
-export function toonToYaml(toonString) {
+export function toonToYamlSync(toonString) {
     if (!toonString || typeof toonString !== 'string') {
         throw new Error('Input must be a non-empty string');
     }
 
-    const jsonObject = toonToJson(toonString);
+    const jsonObject = toonToJsonSync(toonString);
     return yaml.dump(jsonObject);
 }
+
+/**
+ * Converts TOON to YAML format (Async)
+ * @param {string} toonString - TOON formatted string
+ * @returns {Promise<string>} YAML formatted string
+ */
+export async function toonToYaml(toonString) {
+    return toonToYamlSync(toonString);
+}

package/test/basic.test.js

@@ -5,12 +5,12 @@
 
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { jsonToToon, toonToJson } from '../src/json.js';
-import { validateToonString } from '../src/validator.js';
+import { jsonToToonSync, toonToJsonSync } from '../src/json.js';
+import { validateToonStringSync } from '../src/validator.js';
 
 test('JSON to TOON - Simple Object', () => {
     const input = { name: "Alice", age: 30, active: true };
-    const result = jsonToToon(input);
+    const result = jsonToToonSync(input);
 
     assert.ok(result.includes('name: "Alice"'));
     assert.ok(result.includes('age: 30'));
@@ -19,7 +19,7 @@ test('JSON to TOON - Simple Object', () => {
 
 test('JSON to TOON - Array of Primitives', () => {
     const input = { numbers: [1, 2, 3, 4, 5] };
-    const result = jsonToToon(input);
+    const result = jsonToToonSync(input);
 
     assert.ok(result.includes('numbers[5]: 1, 2, 3, 4, 5'));
 });
@@ -31,7 +31,7 @@ test('JSON to TOON - Tabular Array', () => {
             { id: 2, name: "Bob", active: false }
         ]
     };
-    const result = jsonToToon(input);
+    const result = jsonToToonSync(input);
 
     assert.ok(result.includes('users[2]{id,name,active}:'));
     assert.ok(result.includes('1,"Alice",true'));
@@ -40,7 +40,7 @@ test('JSON to TOON - Tabular Array', () => {
 
 test('TOON to JSON - Simple Object', () => {
     const input = `name: "Alice"\nage: 30\nactive: true`;
-    const result = toonToJson(input);
+    const result = toonToJsonSync(input);
 
     assert.strictEqual(result.name, "Alice");
     assert.strictEqual(result.age, 30);
@@ -49,7 +49,7 @@ test('TOON to JSON - Simple Object', () => {
 
 test('TOON to JSON - Array of Primitives', () => {
     const input = `numbers[5]: 1, 2, 3, 4, 5`;
-    const result = toonToJson(input);
+    const result = toonToJsonSync(input);
 
     assert.ok(Array.isArray(result.numbers));
     assert.strictEqual(result.numbers.length, 5);
@@ -58,7 +58,7 @@ test('TOON to JSON - Array of Primitives', () => {
 
 test('TOON to JSON - Tabular Array', () => {
     const input = `users[2]{id,name,active}:\n  1,"Alice",true\n  2,"Bob",false`;
-    const result = toonToJson(input);
+    const result = toonToJsonSync(input);
 
     assert.ok(Array.isArray(result.users));
     assert.strictEqual(result.users.length, 2);
@@ -79,15 +79,15 @@ test('Round-trip Conversion - Object', () => {
         ]
     };
 
-    const toon = jsonToToon(original);
-    const result = toonToJson(toon);
+    const toon = jsonToToonSync(original);
+    const result = toonToJsonSync(toon);
 
     assert.deepStrictEqual(result, original);
 });
 
 test('Validator - Valid TOON', () => {
     const input = `name: "Alice"\nage: 30`;
-    const result = validateToonString(input);
+    const result = validateToonStringSync(input);
 
     assert.strictEqual(result.isValid, true);
     assert.strictEqual(result.error, null);
@@ -95,7 +95,7 @@ test('Validator - Valid TOON', () => {
 
 test('Validator - Invalid TOON (Array Size Mismatch)', () => {
     const input = `items[3]: 1, 2`; // Declared 3, but only 2 items
-    const result = validateToonString(input);
+    const result = validateToonStringSync(input);
 
     assert.strictEqual(result.isValid, false);
     assert.ok(result.error.includes('Array size mismatch'));
@@ -103,7 +103,7 @@ test('Validator - Invalid TOON (Array Size Mismatch)', () => {
 
 test('Validator - Valid Tabular Array', () => {
     const input = `users[2]{id,name}:\n  1,"Alice"\n  2,"Bob"`;
-    const result = validateToonString(input);
+    const result = validateToonStringSync(input);
 
     assert.strictEqual(result.isValid, true);
     assert.strictEqual(result.error, null);
@@ -111,14 +111,14 @@ test('Validator - Valid Tabular Array', () => {
 
 test('Edge Case - Empty Object', () => {
     const input = {};
-    const result = jsonToToon(input);
+    const result = jsonToToonSync(input);
 
     assert.strictEqual(result.trim(), '');
 });
 
 test('Edge Case - Null Value', () => {
     const input = { value: null };
-    const result = jsonToToon(input);
+    const result = jsonToToonSync(input);
 
     assert.ok(result.includes('value: null'));
 });
@@ -132,8 +132,8 @@ test('Edge Case - Nested Objects', () => {
         }
     };
 
-    const toon = jsonToToon(input);
-    const result = toonToJson(toon);
+    const toon = jsonToToonSync(input);
+    const result = toonToJsonSync(toon);
 
     assert.deepStrictEqual(result, input);
 });

package/test/converters.test.js

@@ -5,9 +5,9 @@
 
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { yamlToToon, toonToYaml } from '../src/yaml.js';
-import { xmlToToon, toonToXml } from '../src/xml.js';
-import { csvToToon, csvToToonSync, toonToCsv } from '../src/csv.js';
+import { yamlToToonSync, toonToYamlSync } from '../src/yaml.js';
+import { xmlToToon, toonToXmlSync } from '../src/xml.js';
+import { csvToToon, csvToToonSync, toonToCsvSync } from '../src/csv.js';
 
 // --- YAML Tests ---
 
@@ -16,14 +16,14 @@ test('YAML to TOON - Simple Object', () => {
 name: Alice
 age: 30
 `;
-    const toon = yamlToToon(yaml);
+    const toon = yamlToToonSync(yaml);
     assert.ok(toon.includes('name: "Alice"'));
     assert.ok(toon.includes('age: 30'));
 });
 
 test('TOON to YAML - Simple Object', () => {
     const toon = `name: "Alice"\nage: 30`;
-    const yaml = toonToYaml(toon);
+    const yaml = toonToYamlSync(toon);
     assert.ok(yaml.includes('name: Alice'));
     assert.ok(yaml.includes('age: 30'));
 });
@@ -36,7 +36,7 @@ user:
     - admin
     - editor
 `;
-    const toon = yamlToToon(yaml);
+    const toon = yamlToToonSync(yaml);
     assert.ok(toon.includes('user:'));
     assert.ok(toon.includes('name: "Alice"'));
     assert.ok(toon.includes('roles[2]:'));
@@ -56,7 +56,7 @@ test('XML to TOON - Simple Element', async () => {
 
 test('TOON to XML - Simple Element', () => {
     const toon = `user:\n  name: "Alice"\n  age: 30`;
-    const xml = toonToXml(toon);
+    const xml = toonToXmlSync(toon);
 
     assert.ok(xml.includes('<user>'));
     assert.ok(xml.includes('<name>Alice</name>'));
@@ -111,7 +111,7 @@ test('TOON to CSV - Basic', () => {
   "Alice","Admin"
   "Bob","User"
 `;
-    const csv = toonToCsv(toon);
+    const csv = toonToCsvSync(toon);
 
     assert.ok(csv.includes('name,role'));
     assert.ok(csv.includes('Alice,Admin'));
@@ -124,7 +124,7 @@ Alice,100
 Bob,95`;
 
     const toon = await csvToToon(originalCsv);
-    const finalCsv = toonToCsv(toon);
+    const finalCsv = toonToCsvSync(toon);
 
     // Note: PapaParse might add/remove quotes or change spacing, so exact match isn't always guaranteed
     // But content should be same