toon-formatter 2.0.1 → 2.2.0

package/src/csv.js

@@ -4,38 +4,7 @@
 
 import Papa from 'papaparse';
 import { jsonToToonSync, toonToJsonSync } from './json.js';
-import { extractCsvFromString } from './utils.js';
-
-/**
- * Internal core function to convert pure CSV string to TOON (Async)
- * @param {string} csvString 
- * @returns {Promise<string>}
- */
-function parseCsvToToon(csvString) {
-    return new Promise((resolve, reject) => {
-        Papa.parse(csvString, {
-            header: true,
-            dynamicTyping: true,
-            complete: function (results) {
-                try {
-                    const jsonObject = results.data;
-
-                    if (typeof jsonObject !== "object" || jsonObject === null) {
-                        throw new Error("CSV parsing failed — cannot convert.");
-                    }
-
-                    const toonString = jsonToToonSync(jsonObject);
-                    resolve(toonString);
-                } catch (error) {
-                    reject(error);
-                }
-            },
-            error: function (error) {
-                reject(new Error(`CSV parsing error: ${error.message}`));
-            }
-        });
-    });
-}
+import { extractCsvFromString, flattenObject } from './utils.js';
 
 /**
  * Internal core function to convert pure CSV string to TOON (Sync)
@@ -46,6 +15,7 @@ function parseCsvToToonSync(csvString) {
     const results = Papa.parse(csvString, {
         header: true,
         dynamicTyping: true,
+        skipEmptyLines: true,
     });
 
     if (results.errors && results.errors.length > 0) {
@@ -62,20 +32,9 @@ function parseCsvToToonSync(csvString) {
 }
 
 /**
- * Converts CSV (or mixed text with CSV) to TOON format (Async)
- * @param {string} csvString - CSV formatted string or mixed text
- * @returns {Promise<string>} TOON formatted string
- * @throws {Error} If CSV is invalid
- */
-export async function csvToToon(csvString) {
-    return csvToToonSync(csvString);
-}
-
-/**
- * Converts CSV (or mixed text with CSV) to TOON format (synchronous version)
+ * Converts CSV (or mixed text with CSV) to TOON format (Sync)
  * @param {string} csvString - CSV formatted string or mixed text
  * @returns {string} TOON formatted string
- * @throws {Error} If CSV is invalid
  */
 export function csvToToonSync(csvString) {
     if (!csvString || typeof csvString !== 'string') {
@@ -104,10 +63,18 @@ export function csvToToonSync(csvString) {
 }
 
 /**
- * Converts TOON to CSV format (Synchronous)
+ * Converts CSV (or mixed text with CSV) to TOON format (Async)
+ * @param {string} csvString - CSV formatted string or mixed text
+ * @returns {Promise<string>} TOON formatted string
+ */
+export async function csvToToon(csvString) {
+    return csvToToonSync(csvString);
+}
+
+/**
+ * Converts TOON to CSV format (Sync)
  * @param {string} toonString - TOON formatted string
  * @returns {string} CSV formatted string
- * @throws {Error} If TOON is invalid
  */
 export function toonToCsvSync(toonString) {
     if (!toonString || typeof toonString !== 'string') {
@@ -116,12 +83,14 @@ export function toonToCsvSync(toonString) {
 
     const jsonObject = toonToJsonSync(toonString);
 
-    const csvString = Papa.unparse(jsonObject, {
+    // Flatten the object for CSV
+    const dataToUnparse = Array.isArray(jsonObject)
+        ? jsonObject.map(row => flattenObject(row))
+        : [flattenObject(jsonObject)];
+
+    return Papa.unparse(dataToUnparse, {
         header: true,
-        dynamicTyping: true,
     });
-
-    return csvString;
 }
 
 /**

package/src/csv_formatter/index.js

@@ -0,0 +1,496 @@
+/**
+ * CsvConverter Class
+ */
+
+import { csvToToon, csvToToonSync, toonToCsv, toonToCsvSync } from '../csv.js';
+import { csvToJson, csvToJsonSync, jsonToCsv, jsonToCsvSync } from '../json_formatter/csv.js';
+import { csvToYaml, csvToYamlSync, yamlToCsv, yamlToCsvSync } from '../yaml_formatter/csv.js';
+import { csvToXml, csvToXmlSync, xmlToCsv, xmlToCsvSync } from '../xml_formatter/csv.js';
+import { validateCsvString, validateCsvStringSync } from './validator.js';
+
+export class CsvConverter {
+    /**
+     * Creates a CsvConverter instance
+     * @param {Object} [encryptor=null] - Optional Encryptor instance for encryption support
+     */
+    constructor(encryptor = null) {
+        this.encryptor = encryptor;
+    }
+
+    // --- Helper Methods for Encryption ---
+
+    /**
+     * Applies encryption logic based on conversion mode (synchronous)
+     * @private
+     * @param {Function} fn - The converter function to call
+     * @param {*} data - Data to convert
+     * @param {string} mode - Conversion mode: 'no_encryption', 'middleware', 'ingestion', 'export'
+     * @returns {*} Converted (and possibly encrypted) data
+     */
+    _convertWithEncryption(fn, data, mode) {
+        if (!this.encryptor || mode === 'no_encryption') {
+            return fn(data);
+        }
+
+        switch (mode) {
+            case 'middleware': // Decrypt -> Convert -> Encrypt
+                const decrypted = this.encryptor.decrypt(data);
+                const result = fn(decrypted);
+                return this.encryptor.encrypt(result);
+            case 'ingestion': // Decrypt -> Convert
+                const dec = this.encryptor.decrypt(data);
+                return fn(dec);
+            case 'export': // Convert -> Encrypt
+                const res = fn(data);
+                return this.encryptor.encrypt(res);
+            default:
+                return fn(data);
+        }
+    }
+
+    /**
+     * Applies encryption logic based on conversion mode (asynchronous)
+     * @private
+     * @param {Function} fn - The async converter function to call
+     * @param {*} data - Data to convert
+     * @param {string} mode - Conversion mode: 'no_encryption', 'middleware', 'ingestion', 'export'
+     * @returns {Promise<*>} Converted (and possibly encrypted) data
+     */
+    async _convertWithEncryptionAsync(fn, data, mode) {
+        if (!this.encryptor || mode === 'no_encryption') {
+            return await fn(data);
+        }
+
+        switch (mode) {
+            case 'middleware':
+                const decrypted = this.encryptor.decrypt(data);
+                const result = await fn(decrypted);
+                return this.encryptor.encrypt(result);
+            case 'ingestion':
+                const dec = this.encryptor.decrypt(data);
+                return await fn(dec);
+            case 'export':
+                const res = await fn(data);
+                return this.encryptor.encrypt(res);
+            default:
+                return await fn(data);
+        }
+    }
+
+    // --- TOON Conversions ---
+
+    /**
+     * Convert TOON string to CSV (Sync)
+     * @param {string} toonString - TOON formatted string
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} CSV formatted string
+     */
+    fromToon(toonString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => toonToCsvSync(data),
+            toonString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert TOON string to CSV (Async)
+     * @param {string} toonString - TOON formatted string
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {Promise<string>} CSV formatted string
+     */
+    async fromToonAsync(toonString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => toonToCsv(data),
+            toonString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to TOON string (Sync)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} TOON formatted string
+     */
+    toToon(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => csvToToonSync(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to TOON string (Async)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {Promise<string>} TOON formatted string
+     */
+    async toToonAsync(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => csvToToon(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    // --- JSON Conversions ---
+
+    /**
+     * Convert JSON to CSV (Sync)
+     * @param {Object|string} jsonData - JSON data or string with embedded JSON
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} CSV formatted string
+     */
+    fromJson(jsonData, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => jsonToCsvSync(data),
+            jsonData,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert JSON to CSV (Async)
+     * @param {Object|string} jsonData - JSON data or string with embedded JSON
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {Promise<string>} CSV formatted string
+     */
+    async fromJsonAsync(jsonData, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => jsonToCsv(data),
+            jsonData,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to JSON (Sync)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {Array|string} JSON result
+     */
+    toJson(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => csvToJsonSync(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to JSON (Async)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {Promise<Array|string>} JSON result
+     */
+    async toJsonAsync(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => csvToJson(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    // --- YAML Conversions ---
+
+    /**
+     * Convert YAML string to CSV (Sync)
+     * @param {string} yamlString - YAML formatted string
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} CSV formatted string
+     */
+    fromYaml(yamlString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => yamlToCsvSync(data),
+            yamlString,
+            conversionMode
+        );
+    }
+
+    async fromYamlAsync(yamlString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => yamlToCsv(data),
+            yamlString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to YAML string (Sync)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} YAML formatted string
+     */
+    toYaml(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => csvToYamlSync(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    async toYamlAsync(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => csvToYaml(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    // --- XML Conversions ---
+
+    /**
+     * Convert XML string to CSV (Sync)
+     * @param {string} xmlString - XML formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} CSV formatted string
+     */
+    fromXml(xmlString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => xmlToCsvSync(data),
+            xmlString,
+            conversionMode
+        );
+    }
+
+    async fromXmlAsync(xmlString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => xmlToCsv(data),
+            xmlString,
+            conversionMode
+        );
+    }
+
+    /**
+     * Convert CSV to XML string (Sync)
+     * @param {string} csvString - CSV formatted string (supports mixed text)
+     * @param {Object} [options={}] - Conversion options
+     * @param {string} [options.conversionMode='no_encryption'] - Encryption mode
+     * @returns {string} XML formatted string
+     */
+    toXml(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryption(
+            (data) => csvToXmlSync(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    async toXmlAsync(csvString, options = {}) {
+        const { conversionMode = 'no_encryption' } = options;
+        return this._convertWithEncryptionAsync(
+            async (data) => csvToXml(data),
+            csvString,
+            conversionMode
+        );
+    }
+
+    // --- Validation ---
+
+    /**
+     * Validate CSV string (Sync)
+     * @param {string} csvString - CSV string to validate
+     * @returns {boolean} True if valid
+     */
+    validate(csvString) {
+        return validateCsvStringSync(csvString);
+    }
+
+    async validateAsync(csvString) {
+        return validateCsvString(csvString);
+    }
+
+    // ========================================
+    // Static Methods (Backward Compatibility)
+    // ========================================
+
+    /**
+     * Convert TOON string to CSV (Sync)
+     * @param {string} toonString - TOON formatted string
+     * @returns {string} CSV formatted string
+     */
+    static fromToon(toonString) {
+        return toonToCsvSync(toonString);
+    }
+
+    /**
+     * Convert TOON string to CSV (Async)
+     * @param {string} toonString - TOON formatted string
+     * @returns {Promise<string>} CSV formatted string
+     */
+    static async fromToonAsync(toonString) {
+        return toonToCsv(toonString);
+    }
+
+    /**
+     * Convert CSV to TOON string (Sync)
+     * @param {string} csvString - CSV formatted string
+     * @returns {string} TOON formatted string
+     */
+    static toToon(csvString) {
+        return csvToToonSync(csvString);
+    }
+
+    /**
+     * Convert CSV to TOON string (Async)
+     * @param {string} csvString - CSV formatted string
+     * @returns {Promise<string>} TOON formatted string
+     */
+    static async toToonAsync(csvString) {
+        return csvToToon(csvString);
+    }
+
+    /**
+     * Convert JSON to CSV string (Sync)
+     * @param {Object|string} jsonData - JSON data or string with embedded JSON
+     * @returns {string} CSV formatted string
+     */
+    static fromJson(jsonData) {
+        return jsonToCsvSync(jsonData);
+    }
+
+    /**
+     * Convert JSON to CSV string (Async)
+     * @param {Object|string} jsonData - JSON data or string with embedded JSON
+     * @returns {Promise<string>} CSV formatted string
+     */
+    static async fromJsonAsync(jsonData) {
+        return jsonToCsv(jsonData);
+    }
+
+    /**
+     * Convert CSV to JSON (Sync)
+     * @param {string} csvString - CSV formatted string
+     * @returns {Array|string} JSON result
+     */
+    static toJson(csvString) {
+        return csvToJsonSync(csvString);
+    }
+
+    /**
+     * Convert CSV to JSON (Async)
+     * @param {string} csvString - CSV formatted string
+     * @returns {Promise<Array|string>} JSON result
+     */
+    static async toJsonAsync(csvString) {
+        return csvToJson(csvString);
+    }
+
+    /**
+     * Convert YAML to CSV string (Sync)
+     * @param {string} yamlString - YAML formatted string
+     * @returns {string} CSV formatted string
+     */
+    static fromYaml(yamlString) {
+        return yamlToCsvSync(yamlString);
+    }
+
+    /**
+     * Convert YAML to CSV string (Async)
+     * @param {string} yamlString - YAML formatted string
+     * @returns {Promise<string>} CSV formatted string
+     */
+    static async fromYamlAsync(yamlString) {
+        return yamlToCsv(yamlString);
+    }
+
+    /**
+     * Convert CSV to YAML string (Sync)
+     * @param {string} csvString - CSV formatted string
+     * @returns {string} YAML formatted string
+     */
+    static toYaml(csvString) {
+        return csvToYamlSync(csvString);
+    }
+
+    /**
+     * Convert CSV to YAML string (Async)
+     * @param {string} csvString - CSV formatted string
+     * @returns {Promise<string>} YAML formatted string
+     */
+    static async toYamlAsync(csvString) {
+        return csvToYaml(csvString);
+    }
+
+    /**
+     * Convert XML to CSV string (Sync)
+     * @param {string} xmlString - XML formatted string
+     * @returns {string} CSV formatted string
+     */
+    static fromXml(xmlString) {
+        return xmlToCsvSync(xmlString);
+    }
+
+    /**
+     * Convert XML to CSV string (Async)
+     * @param {string} xmlString - XML formatted string
+     * @returns {Promise<string>} CSV formatted string
+     */
+    static async fromXmlAsync(xmlString) {
+        return xmlToCsv(xmlString);
+    }
+
+    /**
+     * Convert CSV to XML string (Sync)
+     * @param {string} csvString - CSV formatted string
+     * @returns {string} XML formatted string
+     */
+    static toXml(csvString) {
+        return csvToXmlSync(csvString);
+    }
+
+    /**
+     * Convert CSV to XML string (Async)
+     * @param {string} csvString - CSV formatted string
+     * @returns {Promise<string>} XML formatted string
+     */
+    static async toXmlAsync(csvString) {
+        return csvToXml(csvString);
+    }
+
+    /**
+     * Validate CSV string
+     * @param {string} csvString - CSV string to validate
+     * @returns {boolean} True if valid
+     */
+    static validate(csvString) {
+        return validateCsvStringSync(csvString);
+    }
+
+    /**
+     * Validate CSV string (Async)
+     * @param {string} csvString - CSV string to validate
+     * @returns {Promise<boolean>} True if valid
+     */
+    static async validateAsync(csvString) {
+        return validateCsvString(csvString);
+    }
+}

package/src/csv_formatter/validator.js

@@ -0,0 +1,36 @@
+/**
+ * CSV Validator (for CsvConverter)
+ */
+
+import Papa from 'papaparse';
+
+/**
+ * Validate CSV string (Sync)
+ * @param {string} csvString 
+ * @returns {boolean} True if valid, throws error if invalid
+ */
+export function validateCsvStringSync(csvString) {
+    if (typeof csvString !== 'string') {
+        throw new Error("Input must be a string.");
+    }
+
+    const results = Papa.parse(csvString, {
+        header: true,
+        skipEmptyLines: true,
+    });
+
+    if (results.errors && results.errors.length > 0) {
+        throw new Error(`Invalid CSV: ${results.errors[0].message}`);
+    }
+
+    return true;
+}
+
+/**
+ * Validate CSV string (Async)
+ * @param {string} csvString 
+ * @returns {Promise<boolean>} True if valid
+ */
+export async function validateCsvString(csvString) {
+    return validateCsvStringSync(csvString);
+}

package/src/index.js

@@ -24,6 +24,10 @@ import {
     extractCsvFromString
 } from './utils.js';
 import { Encryptor } from './encryptor.js';
+import { JsonConverter } from './json_formatter/index.js';
+import { YamlConverter } from './yaml_formatter/index.js';
+import { XmlConverter } from './xml_formatter/index.js';
+import { CsvConverter } from './csv_formatter/index.js';
 
 // Exports
 export {
@@ -34,7 +38,11 @@ export {
     validateToonString, validateToonStringSync,
     encodeXmlReservedChars, splitByDelimiter, parseValue, formatValue,
     extractJsonFromString, extractXmlFromString, extractCsvFromString,
-    Encryptor
+    Encryptor,
+    JsonConverter,
+    YamlConverter,
+    XmlConverter,
+    CsvConverter
 };
 
 /**