toon-formatter 1.0.0

package/src/xml.js

@@ -0,0 +1,174 @@
+/**
+ * XML ↔ TOON Converter
+ * Note: This module is designed for Node.js environments
+ */
+
+import { jsonToToon, toonToJson } from './json.js';
+import { encodeXmlReservedChars } from './utils.js';
+
+/**
+ * Converts XML DOM to JSON object
+ * @param {Node} xml - XML DOM node
+ * @returns {Object|string|undefined} JSON representation
+ */
+function xmlToJsonObject(xml) {
+    let obj = {};
+
+    if (xml.nodeType === 1) { // Element node
+        if (xml.attributes && xml.attributes.length > 0) {
+            obj["@attributes"] = {};
+            for (let j = 0; j < xml.attributes.length; j++) {
+                const attribute = xml.attributes.item(j);
+                obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
+            }
+        }
+    } else if (xml.nodeType === 3) { // Text node
+        const trimmedText = xml.nodeValue.trim();
+        return trimmedText === "" ? undefined : trimmedText;
+    }
+
+    if (xml.hasChildNodes && xml.hasChildNodes()) {
+        for (let i = 0; i < xml.childNodes.length; i++) {
+            const item = xml.childNodes.item(i);
+            const nodeName = item.nodeName;
+            const childJson = xmlToJsonObject(item);
+
+            if (childJson === undefined) continue;
+
+            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") {
+                    const old = obj[nodeName];
+                    obj[nodeName] = [];
+                    obj[nodeName].push(old);
+                }
+                obj[nodeName].push(childJson);
+            }
+        }
+    }
+
+    // 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) {
+        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;
+}
+
+/**
+ * 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
+ */
+export async function xmlToToon(xmlString) {
+    if (!xmlString || typeof xmlString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+
+    // Check if we're in a browser environment
+    if (typeof DOMParser !== 'undefined') {
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(
+            encodeXmlReservedChars(xmlString),
+            'application/xml'
+        );
+
+        const parserError = xmlDoc.querySelector('parsererror');
+        if (parserError) {
+            throw new Error(parserError.textContent);
+        }
+
+        const jsonObject = xmlToJsonObject(xmlDoc);
+        return jsonToToon(jsonObject);
+    }
+
+    // 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');
+    }
+}
+
+/**
+ * Converts TOON to XML format
+ * @param {string} toonString - TOON formatted string
+ * @returns {string} XML formatted string
+ * @throws {Error} If TOON is invalid
+ */
+export function toonToXml(toonString) {
+    if (!toonString || typeof toonString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+
+    const jsonObject = toonToJson(toonString);
+    return jsonObjectToXml(jsonObject);
+}

package/src/yaml.js

@@ -0,0 +1,41 @@
+/**
+ * YAML ↔ TOON Converter
+ */
+
+import yaml from 'js-yaml';
+import { jsonToToon, toonToJson } from './json.js';
+
+/**
+ * Converts YAML to TOON format
+ * @param {string} yamlString - YAML formatted string
+ * @returns {string} TOON formatted string
+ * @throws {Error} If YAML is invalid
+ */
+export function yamlToToon(yamlString) {
+    if (!yamlString || typeof yamlString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+
+    const jsonObject = yaml.load(yamlString);
+
+    if (typeof jsonObject !== "object" || jsonObject === null) {
+        throw new Error("YAML parsing failed — cannot convert.");
+    }
+
+    return jsonToToon(jsonObject);
+}
+
+/**
+ * Converts TOON to YAML format
+ * @param {string} toonString - TOON formatted string
+ * @returns {string} YAML formatted string
+ * @throws {Error} If TOON is invalid
+ */
+export function toonToYaml(toonString) {
+    if (!toonString || typeof toonString !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+
+    const jsonObject = toonToJson(toonString);
+    return yaml.dump(jsonObject);
+}

package/test/basic.test.js

@@ -0,0 +1,139 @@
+/**
+ * Basic tests for TOON Converter
+ * Run with: node --test test/basic.test.js
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { jsonToToon, toonToJson } from '../src/json.js';
+import { validateToonString } from '../src/validator.js';
+
+test('JSON to TOON - Simple Object', () => {
+    const input = { name: "Alice", age: 30, active: true };
+    const result = jsonToToon(input);
+
+    assert.ok(result.includes('name: "Alice"'));
+    assert.ok(result.includes('age: 30'));
+    assert.ok(result.includes('active: true'));
+});
+
+test('JSON to TOON - Array of Primitives', () => {
+    const input = { numbers: [1, 2, 3, 4, 5] };
+    const result = jsonToToon(input);
+
+    assert.ok(result.includes('numbers[5]: 1, 2, 3, 4, 5'));
+});
+
+test('JSON to TOON - Tabular Array', () => {
+    const input = {
+        users: [
+            { id: 1, name: "Alice", active: true },
+            { id: 2, name: "Bob", active: false }
+        ]
+    };
+    const result = jsonToToon(input);
+
+    assert.ok(result.includes('users[2]{id,name,active}:'));
+    assert.ok(result.includes('1,"Alice",true'));
+    assert.ok(result.includes('2,"Bob",false'));
+});
+
+test('TOON to JSON - Simple Object', () => {
+    const input = `name: "Alice"\nage: 30\nactive: true`;
+    const result = toonToJson(input);
+
+    assert.strictEqual(result.name, "Alice");
+    assert.strictEqual(result.age, 30);
+    assert.strictEqual(result.active, true);
+});
+
+test('TOON to JSON - Array of Primitives', () => {
+    const input = `numbers[5]: 1, 2, 3, 4, 5`;
+    const result = toonToJson(input);
+
+    assert.ok(Array.isArray(result.numbers));
+    assert.strictEqual(result.numbers.length, 5);
+    assert.deepStrictEqual(result.numbers, [1, 2, 3, 4, 5]);
+});
+
+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);
+
+    assert.ok(Array.isArray(result.users));
+    assert.strictEqual(result.users.length, 2);
+    assert.strictEqual(result.users[0].id, 1);
+    assert.strictEqual(result.users[0].name, "Alice");
+    assert.strictEqual(result.users[0].active, true);
+    assert.strictEqual(result.users[1].id, 2);
+    assert.strictEqual(result.users[1].name, "Bob");
+    assert.strictEqual(result.users[1].active, false);
+});
+
+test('Round-trip Conversion - Object', () => {
+    const original = {
+        company: "TechCorp",
+        employees: [
+            { name: "Alice", role: "Engineer" },
+            { name: "Bob", role: "Designer" }
+        ]
+    };
+
+    const toon = jsonToToon(original);
+    const result = toonToJson(toon);
+
+    assert.deepStrictEqual(result, original);
+});
+
+test('Validator - Valid TOON', () => {
+    const input = `name: "Alice"\nage: 30`;
+    const result = validateToonString(input);
+
+    assert.strictEqual(result.isValid, true);
+    assert.strictEqual(result.error, null);
+});
+
+test('Validator - Invalid TOON (Array Size Mismatch)', () => {
+    const input = `items[3]: 1, 2`; // Declared 3, but only 2 items
+    const result = validateToonString(input);
+
+    assert.strictEqual(result.isValid, false);
+    assert.ok(result.error.includes('Array size mismatch'));
+});
+
+test('Validator - Valid Tabular Array', () => {
+    const input = `users[2]{id,name}:\n  1,"Alice"\n  2,"Bob"`;
+    const result = validateToonString(input);
+
+    assert.strictEqual(result.isValid, true);
+    assert.strictEqual(result.error, null);
+});
+
+test('Edge Case - Empty Object', () => {
+    const input = {};
+    const result = jsonToToon(input);
+
+    assert.strictEqual(result.trim(), '');
+});
+
+test('Edge Case - Null Value', () => {
+    const input = { value: null };
+    const result = jsonToToon(input);
+
+    assert.ok(result.includes('value: null'));
+});
+
+test('Edge Case - Nested Objects', () => {
+    const input = {
+        level1: {
+            level2: {
+                level3: "deep"
+            }
+        }
+    };
+
+    const toon = jsonToToon(input);
+    const result = toonToJson(toon);
+
+    assert.deepStrictEqual(result, input);
+});

package/test/converters.test.js

@@ -0,0 +1,135 @@
+/**
+ * Tests for YAML, XML, and CSV Converters
+ * Run with: node --test test/converters.test.js
+ */
+
+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';
+
+// --- YAML Tests ---
+
+test('YAML to TOON - Simple Object', () => {
+    const yaml = `
+name: Alice
+age: 30
+`;
+    const toon = yamlToToon(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);
+    assert.ok(yaml.includes('name: Alice'));
+    assert.ok(yaml.includes('age: 30'));
+});
+
+test('YAML to TOON - Nested Structure', () => {
+    const yaml = `
+user:
+  name: Alice
+  roles:
+    - admin
+    - editor
+`;
+    const toon = yamlToToon(yaml);
+    assert.ok(toon.includes('user:'));
+    assert.ok(toon.includes('name: "Alice"'));
+    assert.ok(toon.includes('roles[2]:'));
+});
+
+// --- XML Tests ---
+
+test('XML to TOON - Simple Element', async () => {
+    const xml = `<user><name>Alice</name><age>30</age></user>`;
+    const toon = await xmlToToon(xml);
+
+    // Note: XML conversion wraps based on root element
+    assert.ok(toon.includes('user:'));
+    assert.ok(toon.includes('name: "Alice"'));
+    assert.ok(toon.includes('age: "30"')); // XML text content is usually string
+});
+
+test('TOON to XML - Simple Element', () => {
+    const toon = `user:\n  name: "Alice"\n  age: 30`;
+    const xml = toonToXml(toon);
+
+    assert.ok(xml.includes('<user>'));
+    assert.ok(xml.includes('<name>Alice</name>'));
+    assert.ok(xml.includes('<age>30</age>'));
+    assert.ok(xml.includes('</user>'));
+});
+
+test('XML to TOON - Attributes', async () => {
+    const xml = `<item id="123" type="widget">Content</item>`;
+    const toon = await xmlToToon(xml);
+
+    assert.ok(toon.includes('item:'));
+    assert.ok(toon.includes('@attributes:'));
+    assert.ok(toon.includes('id: "123"'));
+    assert.ok(toon.includes('type: "widget"'));
+    assert.ok(toon.includes('#text: "Content"'));
+});
+
+// --- CSV Tests ---
+
+test('CSV to TOON - Basic (Async)', async () => {
+    const csv = `name,age,active
+Alice,30,true
+Bob,25,false`;
+
+    const toon = await csvToToon(csv);
+
+    // Should detect as tabular array or array of objects
+    // Since root is array, it might be [2]{name,age,active}: ...
+
+    assert.ok(toon.includes('[2]{name,age,active}:'));
+    assert.ok(toon.includes('Alice'));
+    assert.ok(toon.includes('30'));
+    assert.ok(toon.includes('true'));
+});
+
+test('CSV to TOON - Basic (Sync)', () => {
+    const csv = `id,product
+1,Apple
+2,Banana`;
+
+    const toon = csvToToonSync(csv);
+
+    assert.ok(toon.includes('[2]{id,product}:'));
+    assert.ok(toon.includes('1,"Apple"'));
+    assert.ok(toon.includes('2,"Banana"'));
+});
+
+test('TOON to CSV - Basic', () => {
+    const toon = `
+[2]{name,role}:
+  "Alice","Admin"
+  "Bob","User"
+`;
+    const csv = toonToCsv(toon);
+
+    assert.ok(csv.includes('name,role'));
+    assert.ok(csv.includes('Alice,Admin'));
+    assert.ok(csv.includes('Bob,User'));
+});
+
+test('CSV Round Trip', async () => {
+    const originalCsv = `name,score
+Alice,100
+Bob,95`;
+
+    const toon = await csvToToon(originalCsv);
+    const finalCsv = toonToCsv(toon);
+
+    // Note: PapaParse might add/remove quotes or change spacing, so exact match isn't always guaranteed
+    // But content should be same
+    assert.ok(finalCsv.includes('name'));
+    assert.ok(finalCsv.includes('score'));
+    assert.ok(finalCsv.includes('Alice'));
+    assert.ok(finalCsv.includes('100'));
+});