toon-formatter 1.0.0

package/src/json.js

@@ -0,0 +1,297 @@
+/**
+ * JSON ↔ TOON Converter
+ */
+
+import { formatValue, parseValue, splitByDelimiter } from './utils.js';
+
+/**
+ * Converts JSON to TOON format
+ * @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) {
+    const indent = '  '.repeat(depth);
+    const nextIndent = '  '.repeat(depth + 1);
+
+    // ---- Primitive ----
+    if (data === null || typeof data !== 'object') {
+        return `${indent}${key}: ${formatValue(data)}`;
+    }
+
+    // ---- Array ----
+    if (Array.isArray(data)) {
+        const length = data.length;
+
+        // Empty array
+        if (length === 0) {
+            return `${indent}${key}[0]:`;
+        }
+
+        // Array of primitives
+        if (typeof data[0] !== 'object' || data[0] === null) {
+            const values = data.map(v => formatValue(v)).join(', ');
+            return `${indent}${key}[${length}]: ${values}`;
+        }
+
+        // ---- Array of objects ----
+
+        // Determine if all fields in object are primitives
+        const firstObj = data[0];
+        const fields = Object.keys(firstObj);
+        const isTabular = data.every(row =>
+            fields.every(f =>
+                row[f] === null ||
+                ['string', 'number', 'boolean'].includes(typeof row[f])
+            )
+        );
+
+        // ---- TABULAR ARRAY (structured array) ----
+        if (isTabular) {
+            const header = fields.join(',');
+            const lines = [];
+            lines.push(`${indent}${key}[${length}]{${header}}:`);
+
+            data.forEach(row => {
+                const rowVals = fields.map(f => formatValue(row[f]));
+                lines.push(`${nextIndent}${rowVals.join(',')}`);
+            });
+
+            return lines.join('\n');
+        }
+
+        // ---- YAML-STYLE ARRAY (nested objects present) ----
+        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);
+            }
+        });
+
+        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);
+        }
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Converts TOON to JSON format
+ * @param {string} toonString - TOON formatted string
+ * @returns {*} Parsed JSON data
+ */
+export function toonToJson(toonString) {
+    const lines = toonString.split('\n');
+    let root = {};
+    let stack = [];
+
+    // Pre-process: Check for Root Array or Root Primitive
+    const firstLine = lines.find(l => l.trim() !== '');
+    if (!firstLine) return {}; // Empty document
+
+    // Root Array detection: [N]... at start of line
+    if (firstLine.trim().startsWith('[')) {
+        root = [];
+        stack.push({ obj: root, indent: 0, isRootArray: true });
+    } else {
+        stack.push({ obj: root, indent: -1 }); // Root object container
+    }
+
+    // State for tabular arrays
+    let tabularHeaders = null;
+    let tabularTarget = null;
+    let tabularIndent = -1;
+    let tabularDelimiter = ',';
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === '') continue;
+
+        const indentMatch = line.match(/^(\s*)/);
+        const indent = indentMatch ? indentMatch[1].length : 0;
+        const trimmed = line.trim();
+
+        // --- Tabular Data Handling ---
+        if (tabularTarget) {
+            if (tabularIndent === -1) {
+                if (indent > stack[stack.length - 1].indent) {
+                    tabularIndent = indent;
+                } else {
+                    tabularTarget = null;
+                    tabularHeaders = null;
+                }
+            }
+
+            if (tabularTarget && indent === tabularIndent) {
+                const values = splitByDelimiter(trimmed, tabularDelimiter).map(parseValue);
+                const rowObj = {};
+                tabularHeaders.forEach((h, idx) => {
+                    rowObj[h] = values[idx];
+                });
+                tabularTarget.push(rowObj);
+                continue;
+            } else if (tabularTarget && indent < tabularIndent) {
+                tabularTarget = null;
+                tabularHeaders = null;
+                tabularIndent = -1;
+            }
+        }
+
+        // Adjust stack based on indentation
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+
+        let parent = stack[stack.length - 1].obj;
+
+        // Root Array Header check
+        if (stack.length === 1 && stack[0].isRootArray && trimmed.startsWith('[')) {
+            const rootHeaderMatch = trimmed.match(/^\[(\d+)(.*?)\](?:\{(.*?)\})?:\s*(.*)$/);
+            if (rootHeaderMatch) {
+                const delimChar = rootHeaderMatch[2];
+                const fieldsStr = rootHeaderMatch[3];
+
+                let delimiter = ',';
+                if (delimChar === '\\t') delimiter = '\t';
+                else if (delimChar === '|') delimiter = '|';
+
+                if (fieldsStr) {
+                    tabularHeaders = fieldsStr.split(',').map(s => s.trim());
+                    tabularTarget = root;
+                    tabularIndent = -1;
+                    tabularDelimiter = delimiter;
+                }
+            }
+            continue;
+        }
+
+        // --- List Item Handling (-) ---
+        if (trimmed.startsWith('-')) {
+            const content = trimmed.slice(1).trim();
+
+            if (content === '') {
+                const newObj = {};
+                parent.push(newObj);
+                stack.push({ obj: newObj, indent: indent });
+                continue;
+            } else {
+                const kvMatch = content.match(/^(.+?):\s*(.*)$/);
+                const arrayMatch = content.match(/^\[(\d+)(.*?)\](?:\{(.*?)\})?:\s*(.*)$/);
+
+                if (arrayMatch) {
+                    const length = parseInt(arrayMatch[1], 10);
+                    const delimChar = arrayMatch[2] || ',';
+                    const delimiter = delimChar === '\\t' ? '\t' : (delimChar === '|' ? '|' : ',');
+                    const fieldsStr = arrayMatch[3];
+                    const rest = arrayMatch[4];
+
+                    const newArray = [];
+                    parent.push(newArray);
+
+                    if (fieldsStr) {
+                        tabularHeaders = fieldsStr.split(',').map(s => s.trim());
+                        tabularTarget = newArray;
+                        tabularIndent = -1;
+                        tabularDelimiter = delimiter;
+                    } else if (rest) {
+                        const values = splitByDelimiter(rest, delimiter).map(parseValue);
+                        newArray.push(...values);
+                    } else {
+                        stack.push({ obj: newArray, indent: indent + 1 });
+                    }
+                    continue;
+                }
+
+                if (kvMatch) {
+                    const key = kvMatch[1].trim();
+                    const valStr = kvMatch[2].trim();
+                    const newObj = {};
+
+                    if (valStr === '') {
+                        newObj[key] = {};
+                        parent.push(newObj);
+                        stack.push({ obj: newObj[key], indent: indent + 1 });
+                    } else {
+                        newObj[key] = parseValue(valStr);
+                        parent.push(newObj);
+                        stack.push({ obj: newObj, indent: indent });
+                    }
+                    continue;
+                }
+
+                parent.push(parseValue(content));
+                continue;
+            }
+        }
+
+        // --- Key-Value or Array Header Handling ---
+        const arrayHeaderMatch = trimmed.match(/^(.+?)\[(\d+)(.*?)\](?:\{(.*?)\})?:\s*(.*)$/);
+
+        if (arrayHeaderMatch) {
+            const key = arrayHeaderMatch[1].trim();
+            const length = parseInt(arrayHeaderMatch[2], 10);
+            const delimChar = arrayHeaderMatch[3];
+            const fieldsStr = arrayHeaderMatch[4];
+            const valueStr = arrayHeaderMatch[5];
+
+            let delimiter = ',';
+            if (delimChar === '\\t') delimiter = '\t';
+            else if (delimChar === '|') delimiter = '|';
+
+            const newArray = [];
+
+            if (!Array.isArray(parent)) {
+                parent[key] = newArray;
+            }
+
+            if (fieldsStr) {
+                tabularHeaders = fieldsStr.split(',').map(s => s.trim());
+                tabularTarget = newArray;
+                tabularIndent = -1;
+                tabularDelimiter = delimiter;
+            } else if (valueStr && valueStr.trim() !== '') {
+                const values = splitByDelimiter(valueStr, delimiter).map(parseValue);
+                newArray.push(...values);
+            } else {
+                stack.push({ obj: newArray, indent: indent + 1 });
+            }
+            continue;
+        }
+
+        // Standard Key-Value: key: value
+        const kvMatch = trimmed.match(/^(.+?):\s*(.*)$/);
+        if (kvMatch) {
+            const key = kvMatch[1].trim();
+            const valStr = kvMatch[2].trim();
+
+            if (valStr === '') {
+                const newObj = {};
+                parent[key] = newObj;
+                stack.push({ obj: newObj, indent: indent + 1 });
+            } else {
+                parent[key] = parseValue(valStr);
+            }
+            continue;
+        }
+    }
+
+    return root;
+}

package/src/utils.js

@@ -0,0 +1,81 @@
+/**
+ * Utility functions for TOON conversion
+ */
+
+/**
+ * Encodes XML reserved characters to prevent parsing errors
+ * @param {string} rawXmlString - Raw XML string
+ * @returns {string} Encoded XML string
+ */
+export function encodeXmlReservedChars(rawXmlString) {
+    if (typeof rawXmlString !== 'string') {
+        return '';
+    }
+
+    let encodedString = rawXmlString;
+    const ampersandRegex = /&(?!#|\w+;)/g;
+    encodedString = encodedString.replace(ampersandRegex, '&');
+    return encodedString;
+}
+
+/**
+ * Splits a string by delimiter while respecting quoted strings
+ * @param {string} text - Text to split
+ * @param {string} delimiter - Delimiter character
+ * @returns {string[]} Array of split values
+ */
+export function splitByDelimiter(text, delimiter) {
+    const result = [];
+    let current = '';
+    let inQuote = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === '"' && (i === 0 || text[i - 1] !== '\\')) {
+            inQuote = !inQuote;
+        }
+        if (char === delimiter && !inQuote) {
+            result.push(current);
+            current = '';
+        } else {
+            current += char;
+        }
+    }
+    result.push(current);
+    return result;
+}
+
+/**
+ * Parses a value string into its correct JavaScript type
+ * @param {string} val - Value string to parse
+ * @returns {*} Parsed value (string, number, boolean, or null)
+ */
+export function parseValue(val) {
+    val = val.trim();
+    if (val === 'true') return true;
+    if (val === 'false') return false;
+    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);
+    if (val === '0') return 0;
+    if (val.match(/^-?0\./)) return Number(val); // 0.5, -0.5
+
+    // String unquoting
+    if (val.startsWith('"') && val.endsWith('"')) {
+        // Remove surrounding quotes and unescape internal quotes
+        return val.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    return val;
+}
+
+/**
+ * Formats a value according to TOON rules
+ * @param {*} v - Value to format
+ * @returns {string} Formatted value
+ */
+export function formatValue(v) {
+    if (v === null) return "null";
+    if (typeof v === "string") return `"${v.replace(/"/g, '\\"')}"`;
+    return v; // number, boolean
+}

package/src/validator.js

@@ -0,0 +1,218 @@
+/**
+ * TOON String Validator
+ */
+
+import { splitByDelimiter } from './utils.js';
+
+/**
+ * Validates a TOON string for syntax and structural correctness
+ * @param {string} toonString - TOON string to validate
+ * @returns {{isValid: boolean, error: string|null}} Validation result
+ */
+export function validateToonString(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? }
+    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
+        rootArray: /^\[(\d+)([\t|])?\](?:\{[^}]+\})?:\s*(.*)$/,    // Capture N, delimiter, content
+        listItem: /^\-.*/,
+        listItemEmpty: /^\-\s*$/,
+        keyValue: /^[^:\[]+:\s*(?:".*?"|[^"].*)$/,
+        tabularRow: /^\s*[^:]+\s*$/,
+    };
+
+    let isInsideTabularArray = false;
+
+    function opensNewBlock(trimmedLine) {
+        return trimmedLine.match(REGEX.mapKey) ||
+            trimmedLine.match(REGEX.arrayKey) ||
+            trimmedLine.match(REGEX.rootArray) ||
+            trimmedLine.match(REGEX.listItemEmpty);
+    }
+
+    function startsTabular(trimmedLine) {
+        const isArray = trimmedLine.match(REGEX.arrayKey) || trimmedLine.match(REGEX.rootArray);
+        return isArray && trimmedLine.includes('{') && trimmedLine.includes('}');
+    }
+
+    for (const rawLine of lines) {
+        lineNumber++;
+        const line = rawLine.trimEnd();
+
+        if (line.trim() === '' || line.trim().startsWith('#')) {
+            continue;
+        }
+
+        const trimmedLine = line.trim();
+        const currentIndent = rawLine.search(/\S|$/);
+        const currentContext = contextStack[contextStack.length - 1];
+        const requiredIndent = currentContext.indent;
+
+        // --- Inline Array Validation ---
+        let arrayMatch = trimmedLine.match(REGEX.arrayKey) || trimmedLine.match(REGEX.rootArray);
+        if (arrayMatch) {
+            const size = parseInt(arrayMatch[1], 10);
+            const delimChar = arrayMatch[2];
+            const content = arrayMatch[3];
+
+            if (content && content.trim() !== '') {
+                // Inline Array: Validate immediately
+                let delimiter = ',';
+                if (delimChar === '\\t') delimiter = '\t';
+                else if (delimChar === '|') delimiter = '|';
+
+                const items = splitByDelimiter(content, delimiter);
+                const validItems = items.filter(i => i.trim() !== '');
+
+                if (validItems.length !== size) {
+                    return { isValid: false, error: `L${lineNumber}: Array size mismatch. Declared ${size}, found ${validItems.length} inline items.` };
+                }
+            } else {
+                // Block Array start. 
+                if (trimmedLine.match(REGEX.rootArray) && contextStack.length === 1) {
+                    contextStack[0].type = 'array';
+                    contextStack[0].expected = size;
+                    contextStack[0].count = 0;
+                }
+            }
+        }
+
+        // --- State Management (Tabular) ---
+        if (isInsideTabularArray) {
+            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.` };
+                }
+                if (rootContext.type === 'array') {
+                    rootContext.count++;
+                }
+                if (rootContext.indent === 0) {
+                    rootContext.indent = currentIndent;
+                }
+                continue;
+            } else {
+                isInsideTabularArray = false;
+            }
+        }
+
+        // --- Indentation Check ---
+        if (currentIndent > requiredIndent) {
+            // New Block
+            const prevLineTrimmed = lines[lineNumber - 2] ? lines[lineNumber - 2].trim() : '';
+            if (!opensNewBlock(prevLineTrimmed)) {
+                return { isValid: false, error: `L${lineNumber}: Indentation error.` };
+            }
+
+            let newContext = { indent: currentIndent, type: 'object' };
+
+            const prevArrayMatch = prevLineTrimmed.match(REGEX.arrayKey) || prevLineTrimmed.match(REGEX.rootArray);
+            if (prevArrayMatch) {
+                const isRootArrayAlreadySet = prevLineTrimmed.match(REGEX.rootArray) &&
+                    contextStack.length === 1 &&
+                    contextStack[0].type === 'array';
+
+                if (!isRootArrayAlreadySet) {
+                    const size = parseInt(prevArrayMatch[1], 10);
+                    newContext = { indent: currentIndent, type: 'array', expected: size, count: 0 };
+                    contextStack.push(newContext);
+                }
+            } else {
+                contextStack.push(newContext);
+            }
+
+            if (contextStack.length === 1 && contextStack[0].type === 'array' && contextStack[0].indent === 0) {
+                contextStack[0].indent = currentIndent;
+            }
+
+            const targetContext = contextStack[contextStack.length - 1];
+            if (targetContext.type === 'array') {
+                if (trimmedLine.match(REGEX.listItem)) {
+                    targetContext.count++;
+                }
+            }
+
+        } else if (currentIndent < requiredIndent) {
+            // Un-indentation
+            let foundMatch = false;
+
+            while (contextStack.length > 1) {
+                const popped = contextStack.pop();
+
+                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}).` };
+                    }
+                }
+
+                if (currentIndent === contextStack[contextStack.length - 1].indent) {
+                    foundMatch = true;
+                    break;
+                }
+            }
+
+            if (!foundMatch && currentIndent !== 0) {
+                return { isValid: false, error: `L${lineNumber}: Invalid un-indentation.` };
+            }
+
+            const parentContext = contextStack[contextStack.length - 1];
+            if (parentContext.type === 'array') {
+                if (trimmedLine.match(REGEX.listItem)) {
+                    parentContext.count++;
+                }
+            }
+
+        } else {
+            // Same Indent
+            if (currentContext.type === 'array') {
+                if (trimmedLine.match(REGEX.listItem)) {
+                    currentContext.count++;
+                }
+            }
+        }
+
+        // --- 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.includes(':')) {
+            if (!trimmedLine.match(REGEX.keyValue)) {
+                return { isValid: false, error: `L${lineNumber}: Invalid Key-Value assignment.` };
+            }
+        }
+        else if (trimmedLine.startsWith('"') && trimmedLine.endsWith('"')) { }
+        else {
+            return { isValid: false, error: `L${lineNumber}: Unrecognized TOON syntax.` };
+        }
+    }
+
+    // Final check
+    while (contextStack.length > 1) {
+        const popped = contextStack.pop();
+        if (popped.type === 'array') {
+            if (popped.count !== popped.expected) {
+                return { isValid: false, error: `Array size mismatch. Declared ${popped.expected}, found ${popped.count} items.` };
+            }
+        }
+    }
+
+    // Check root array if applicable
+    if (contextStack[0].type === 'array') {
+        if (contextStack[0].count !== contextStack[0].expected) {
+            return { isValid: false, error: `Root Array size mismatch. Declared ${contextStack[0].expected}, found ${contextStack[0].count} items.` };
+        }
+    }
+
+    return { isValid: true, error: null };
+}