API Reference

function xmlToJson(xml, includeAttributes) {
  const result = {};

  // Handle attributes
  if (includeAttributes && xml.attributes.length > 0) {
    result['@attributes'] = {};
    for (let i = 0; i < xml.attributes.length; i++) {
      const attr = xml.attributes[i];
      result['@attributes'][attr.name] = attr.value;
    }
  }

  // Handle child nodes
  const children = xml.childNodes;
  let hasTextContent = false;
  let textContent = '';

  for (let i = 0; i < children.length; i++) {
    const child = children[i];

    if (child.nodeType === Node.TEXT_NODE) {
      const text = child.textContent?.trim();
      if (text) {
        hasTextContent = true;
        textContent += text;
      }
    } else if (child.nodeType === Node.ELEMENT_NODE) {
      const childElement = child;
      const childName = childElement.tagName;

      if (!result[childName]) {
        result[childName] = [];
      }

      result[childName].push(xmlToJson(childElement, includeAttributes));
    }
  }

  // Add text content if present
  if (hasTextContent) {
    result['#text'] = textContent;
  }

  // Optimize single child elements
  const keys = Object.keys(result);
  if (keys.length === 1 && keys[0] !== '@attributes' && keys[0] !== '#text') {
    const childArray = result[keys[0]];
    if (Array.isArray(childArray) && childArray.length === 1) {
      return childArray[0];
    }
  }

  return result;
}

<root>
  <element attribute="value">Text content</element>
  <nested>
    <child>Child content</child>
  </nested>
</root>

{
  "root": {
    "element": {
      "@attributes": {
        "attribute": "value"
      },
      "#text": "Text content"
    },
    "nested": {
      "child": "Child content"
    }
  }
}

interface ConversionOptions {
  prettyPrint: boolean; // Format JSON with indentation
  includeAttributes: boolean; // Include XML attributes in output
}

interface HistoryRecord {
  id: string; // Unique identifier
  inputXml: string; // Original XML content
  outputJson: string; // Converted JSON
  inputLength: number; // Length of input XML
  prettyPrint: boolean; // Pretty print setting used
  includeAttributes: boolean; // Attribute inclusion setting
  timestamp: number; // Conversion timestamp
}

interface ValidationError {
  type: 'parse_error' | 'malformed_xml' | 'invalid_character';
  message: string;
  line?: number;
  column?: number;
}

// Basic usage
function convertXmlToJson(xmlString, options = {}) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlString, 'text/xml');

  // Check for parsing errors
  const parserError = xmlDoc.querySelector('parsererror');
  if (parserError) {
    throw new Error('Invalid XML format');
  }

  const jsonResult = xmlToJson(xmlDoc.documentElement, options.includeAttributes);

  if (options.prettyPrint) {
    return JSON.stringify(jsonResult, null, 2);
  } else {
    return JSON.stringify(jsonResult);
  }
}

// Usage example
try {
  const xmlData = '<root><item>value</item></root>';
  const jsonData = convertXmlToJson(xmlData, {
    prettyPrint: true,
    includeAttributes: true,
  });
  console.log(jsonData);
} catch (error) {
  console.error('Conversion failed:', error.message);
}

<template>
  <div>
    <textarea v-model="xmlInput" @input="convertXml"></textarea>
    <textarea v-model="jsonOutput" readonly></textarea>
  </div>
</template>

<script setup>
import { ref, watch } from 'vue';

const xmlInput = ref('');
const jsonOutput = ref('');

const convertXml = () => {
  try {
    const result = convertXmlToJson(xmlInput.value, {
      prettyPrint: true,
      includeAttributes: true,
    });
    jsonOutput.value = result;
  } catch (error) {
    jsonOutput.value = `Error: ${error.message}`;
  }
};
</script>

import React, { useState, useCallback } from 'react';

function XmlToJsonConverter() {
  const [xmlInput, setXmlInput] = useState('');
  const [jsonOutput, setJsonOutput] = useState('');

  const convertXml = useCallback(() => {
    try {
      const result = convertXmlToJson(xmlInput, {
        prettyPrint: true,
        includeAttributes: true,
      });
      setJsonOutput(result);
    } catch (error) {
      setJsonOutput(`Error: ${error.message}`);
    }
  }, [xmlInput]);

  return (
    <div>
      <textarea
        value={xmlInput}
        onChange={(e) => setXmlInput(e.target.value)}
        onInput={convertXml}
      />
      <textarea value={jsonOutput} readOnly />
    </div>
  );
}

// Test cases for XML to JSON conversion
describe('XML to JSON Converter', () => {
  test('converts simple XML to JSON', () => {
    const xml = '<root><item>value</item></root>';
    const result = convertXmlToJson(xml);
    expect(result).toBe('{"root":{"item":"value"}}');
  });

  test('handles attributes correctly', () => {
    const xml = '<root id="1"><item>value</item></root>';
    const result = convertXmlToJson(xml, { includeAttributes: true });
    const parsed = JSON.parse(result);
    expect(parsed.root['@attributes'].id).toBe('1');
  });

  test('throws error for malformed XML', () => {
    const xml = '<root><item>value</root>';
    expect(() => convertXmlToJson(xml)).toThrow('Invalid XML format');
  });
});

// XML validation
function isValidXml(xmlString) {
  try {
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
    const parserError = xmlDoc.querySelector('parsererror');
    return !parserError;
  } catch (error) {
    return false;
  }
}

// JSON validation
function isValidJson(jsonString) {
  try {
    JSON.parse(jsonString);
    return true;
  } catch (error) {
    return false;
  }
}

// Enable debug logging
const DEBUG = true;

function convertXmlToJson(xml, options = {}) {
  if (DEBUG) {
    console.log('Converting XML:', xml.substring(0, 100) + '...');
    console.log('Options:', options);
  }

  // ... conversion logic

  if (DEBUG) {
    console.log('Conversion completed');
  }

  return result;
}