Free Online JSON to TOON Converter

import json
import csv
from io import StringIO

def json_to_toon(json_data, delimiter=",", optimize_arrays=True):
    """
    Convert JSON to TOON format with advanced optimization
    
    Args:
        json_data: JSON string or Python object
        delimiter: Field separator (',', '|', '\t', ';')
        optimize_arrays: Enable array-to-table optimization
    
    Returns:
        Optimized TOON format string
    """
    
    if isinstance(json_data, str):
        data = json.loads(json_data)
    else:
        data = json_data
    
    def convert_array_to_table(arr):
        if not arr or not isinstance(arr[0], dict):
            return str(arr)
        
        # Get all unique keys
        keys = set()
        for item in arr:
            keys.update(item.keys())
        keys = sorted(keys)
        
        # Create CSV-like format
        output = StringIO()
        writer = csv.writer(output, delimiter=delimiter)
        writer.writerow(keys)
        
        for item in arr:
            row = [item.get(key, '') for key in keys]
            writer.writerow(row)
            
        return output.getvalue().strip()
    
    def process_object(obj, prefix=""):
        if isinstance(obj, list) and optimize_arrays:
            return convert_array_to_table(obj)
        elif isinstance(obj, dict):
            result = []
            for key, value in obj.items():
                if isinstance(value, (dict, list)):
                    nested = process_object(value, f"{prefix}{key}.")
                    result.append(f"{key}:\n{nested}")
                else:
                    result.append(f"{key}{delimiter}{value}")
            return "\n".join(result)
        else:
            return str(obj)
    
    return process_object(data)

# Example usage
json_input = '''{"users": [{"id": 1, "name": "John"}], "count": 1}'''
toon_output = json_to_toon(json_input)
print(f"Original tokens: ~{len(json_input.split())}")
print(f"TOON tokens: ~{len(toon_output.split())}")
print(f"Reduction: ~{(1 - len(toon_output.split())/len(json_input.split()))*100:.1f}%")

class JsonToToonConverter {
    constructor(options = {}) {
        this.delimiter = options.delimiter || ',';
        this.optimizeArrays = options.optimizeArrays !== false;
        this.removeNulls = options.removeNulls || false;
        this.compressStrings = options.compressStrings || false;
    }
    
    /**
     * Convert JSON to TOON format with token optimization
     * @param {string|object} jsonData - JSON input
     * @returns {string} Optimized TOON format
     */
    convert(jsonData) {
        const data = typeof jsonData === 'string' 
            ? JSON.parse(jsonData) 
            : jsonData;
            
        return this.processValue(data);
    }
    
    processValue(value, depth = 0) {
        if (value === null || value === undefined) {
            return this.removeNulls ? '' : 'null';
        }
        
        if (typeof value === 'string') {
            if (this.compressStrings && value.length > 50) {
                return '"' + value.replace(/\s+/g, ' ').trim() + '"';
            }
            return '"' + value + '"';
        }
        
        if (typeof value === 'number' || typeof value === 'boolean') {
            return String(value);
        }
        
        if (Array.isArray(value)) {
            return this.optimizeArrays && this.canOptimizeArray(value)
                ? this.arrayToTable(value)
                : '[' + value.map(item => this.processValue(item, depth + 1))
                    .join(this.delimiter) + ']';
        }
        
        if (typeof value === 'object') {
            const entries = Object.entries(value)
                .filter(([_, v]) => !this.removeNulls || (v !== null && v !== undefined));
                
            return entries.map(([key, val]) => 
                key + this.delimiter + this.processValue(val, depth + 1)
            ).join('\n');
        }
        
        return String(value);
    }
    
    canOptimizeArray(arr) {
        return arr.length > 0 && 
               typeof arr[0] === 'object' && 
               arr[0] !== null &&
               !Array.isArray(arr[0]);
    }
    
    arrayToTable(arr) {
        const keys = [...new Set(arr.flatMap(Object.keys))];
        const header = keys.join(this.delimiter);
        const rows = arr.map(item => 
            keys.map(key => item[key] ?? '').join(this.delimiter)
        );
        return header + '\n' + rows.join('\n');
    }
    
    /**
     * Calculate token reduction estimate
     * @param {string} original - Original JSON
     * @param {string} converted - TOON format
     * @returns {object} Statistics
     */
    calculateSavings(original, converted) {
        const originalTokens = this.estimateTokens(original);
        const convertedTokens = this.estimateTokens(converted);
        const reduction = ((originalTokens - convertedTokens) / originalTokens) * 100;
        const savings = ((originalTokens - convertedTokens) / 1000) * 0.03; // GPT-4 pricing
        
        return {
            originalTokens,
            convertedTokens,
            reduction: Math.max(0, reduction),
            savings: Math.max(0, savings),
            compressionRatio: originalTokens / convertedTokens
        };
    }
    
    estimateTokens(text) {
        const words = text.split(/\s+/).filter(Boolean).length;
        const punctuation = (text.match(/[.,;:!?(){}\[\]"']/g) || []).length;
        const numbers = (text.match(/\d+/g) || []).length;
        return Math.ceil((words + punctuation * 0.5 + numbers * 0.5) * 1.2);
    }
}

// Usage example
const converter = new JsonToToonConverter({
    delimiter: ',',
    optimizeArrays: true,
    removeNulls: true,
    compressStrings: true
});

const jsonData = '{"users": [{"id": 1, "name": "John"}]}';
const toonData = converter.convert(jsonData);
const stats = converter.calculateSavings(jsonData, toonData);

console.log('TOON Output:', toonData);
console.log('Token Reduction:', stats.reduction.toFixed(1) + '%');
console.log('API Savings: $' + stats.savings.toFixed(4));