convert-csv-to-json 3.12.0 → 3.13.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- New `csvStringToJsonStringified()` method that converts CSV content directly to a validated JSON string without requiring file I/O
+- Improved test coverage for string-based CSV parsing
+
+### Changed
+- No breaking changes - all existing APIs remain unchanged

package/README.md

@@ -41,6 +41,7 @@ show your :heart: and support.
       - [Number](#number)
       - [Boolean](#boolean)
     + [Encoding](#encoding)
+    + [Working with CSV strings directly](#working-with-csv-strings-directly)
   * [Chaining Pattern](#chaining-pattern)
 - [Development](#development)
 - [CI CD github action](#ci-cd-github-action)
@@ -220,13 +221,49 @@ If the header is not on the first line you can define the header index like:
 Empty rows are ignored and not parsed.
 
 #### Format property value by type
-If you want that a number will be printed as a Number type, and values *true* or *false* is printed as a boolean Type, use:
+The `formatValueByType()` function intelligently converts string values to their appropriate types while preserving data integrity. To enable automatic type conversion:
+
 ```js
- csvToJson.formatValueByType()
-            .getJsonFromCsv(fileInputName);
+csvToJson.formatValueByType()
+         .getJsonFromCsv(fileInputName);
 ```
-For example: 
 
+This conversion follows these rules:
+
+##### Numbers
+- Regular integers and decimals are converted to Number type
+- Numbers with leading zeros are preserved as strings (e.g., "0012" stays "0012")
+- Large integers outside JavaScript's safe range are preserved as strings
+- Valid decimal numbers are converted to Number type
+
+For example:
+```json
+{
+  "normalInteger": 42,           // Converted to number
+  "decimal": 3.14,              // Converted to number
+  "leadingZeros": "0012345",    // Kept as string to preserve leading zeros
+  "largeNumber": "9007199254740992"  // Kept as string to preserve precision
+}
+```
+
+##### Boolean
+Case-insensitive "true" or "false" strings are converted to boolean values:
+```json
+{
+  "registered": true,     // From "true" or "TRUE" or "True"
+  "active": false        // From "false" or "FALSE" or "False"
+}
+```
+
+##### Complete Example
+Input CSV:
+```csv
+first_name;last_name;email;gender;age;id;zip;registered
+Constantin;Langsdon;clangsdon0@hc360.com;Male;96;00123;123;true
+Norah;Raison;nraison1@wired.com;Female;32;987;00456;FALSE
+```
+
+Output JSON:
 ```json
 [
  {
@@ -235,8 +272,9 @@ For example:
   "email": "clangsdon0@hc360.com",
   "gender": "Male",
   "age": 96,
-  "zip": 123,
-  "registered": true
+  "id": "00123",        // Preserved leading zeros
+  "zip": 123,          // Converted to number
+  "registered": true   // Converted to boolean
  },
  {
   "first_name": "Norah",
@@ -244,29 +282,12 @@ For example:
   "email": "nraison1@wired.com",
   "gender": "Female",
   "age": 32,
-  "zip": "",
-  "registered": false
+  "id": "987",
+  "zip": "00456",      // Preserved leading zeros
+  "registered": false  // Case-insensitive boolean conversion
  }
 ]
 ```
-##### Number
-The property **age** is printed as 
-```json
- "age": 32
-```
-instead of
-```json
-  "age": "32"
- ```
-##### Boolean
-The property **registered** is printed as 
-```json
- "registered": true
-```
-instead of
-```json
-  "registered": "true"
- ```
 
 #### Encoding
 You can read and decode files with the following encoding:
@@ -306,6 +327,30 @@ You can read and decode files with the following encoding:
                   .getJsonFromCsv(fileInputName);
       ```
 
+#### Working with CSV strings directly
+If you have CSV content as a string (for example, from an API response or test data), you can parse it directly without writing to a file:
+
+```js
+
+// Parse CSV string to array of objects
+let csvString = 'firstName;lastName\nJohn;Doe\nJane;Smith';
+let jsonArray = csvToJson.csvStringToJson(csvString);
+// Output: [{"firstName":"John","lastName":"Doe"},{"firstName":"Jane","lastName":"Smith"}]
+
+// Parse CSV string to JSON string (validated)
+let jsonString = csvToJson.csvStringToJsonStringified(csvString);
+// Output: "[\n {\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\"\n },\n {\n  \"firstName\": \"Jane\",\n  \"lastName\": \"Smith\"\n }\n]"
+```
+
+Both methods support all configuration options through the chaining pattern:
+
+```js
+let jsonArray = csvToJson
+  .fieldDelimiter(',')
+  .formatValueByType()
+  .csvStringToJson(csvString);
+```
+
 ### Chaining Pattern
 
 The exposed API is implemented with the [Method Chaining Pattern](https://en.wikipedia.org/wiki/Method_chaining), which means that multiple methods can be chained, e.g.:

package/index.d.ts

@@ -92,6 +92,14 @@ declare module 'convert-csv-to-json' {
     getJsonFromCsv(inputFileName: string): any[];
 
     csvStringToJson(csvString: string): any[];
+
+    /**
+    * Parses a csv string and returns a JSON string (validated)
+    * @param {csvString} csvString CSV content as string
+    * @return {string} JSON stringified result
+    */
+    csvStringToJsonStringified(csvString: string): string;
+    
     /**
      * Parses .csv file and put its content into a file in json format.
      * @param {inputFileName} path/filename

package/index.js

@@ -156,6 +156,18 @@ exports.csvStringToJson = function(csvString) {
   return csvToJson.csvStringToJson(csvString);
 };
 
+/**
+ * Parses a csv string and returns a JSON string (validated)
+ * @param {csvString} csvString CSV content as string
+ * @return {string} JSON stringified result
+ */
+exports.csvStringToJsonStringified = function(csvString) {
+  if (csvString === undefined || csvString === null) {
+    throw new Error("csvString is not defined!!!");
+  }
+  return csvToJson.csvStringToJsonStringified(csvString);
+};
+
 /**
  * Parses .csv file and put its content into a file in json format.
  * @param {inputFileName} path/filename

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convert-csv-to-json",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "description": "Convert CSV to JSON",
   "main": "index.js",
   "types": "index.d.ts",

package/src/csvToJson.js

@@ -69,6 +69,13 @@ class CsvToJson {
     return this.csvToJson(csvString);
   }
 
+  csvStringToJsonStringified(csvString) {
+    let json = this.csvStringToJson(csvString);
+    let jsonStringified = JSON.stringify(json, undefined, 1);
+    jsonUtils.validateJson(jsonStringified);
+    return jsonStringified;
+  }
+
   csvToJson(parsedCsv) {
   	this.validateInputConfig();
     let lines = parsedCsv.split(newLine);

package/src/util/stringUtils.js

@@ -1,40 +1,109 @@
 'use strict';
 
 class StringUtils {
+    // Regular expressions as constants for better maintainability
+    static PATTERNS = {
+        INTEGER: /^-?\d+$/,
+        FLOAT: /^-?\d*\.\d+$/,
+        WHITESPACE: /\s/g
+    };
 
-    trimPropertyName(isTrimHeaderFieldWhiteSpace,value) {
-        if(isTrimHeaderFieldWhiteSpace) {
-            return value.replace(/\s/g, '');
+    static BOOLEAN_VALUES = {
+        TRUE: 'true',
+        FALSE: 'false'
+    };
+
+    /**
+     * Removes whitespace from property names based on configuration
+     * @param {boolean} shouldTrimAll - If true, removes all whitespace, otherwise only trims edges
+     * @param {string} propertyName - The property name to process
+     * @returns {string} The processed property name
+     */
+    trimPropertyName(shouldTrimAll, propertyName) {
+        if (!propertyName) {
+            return '';
         }
-        return value.trim();
-        
+        return shouldTrimAll ? 
+            propertyName.replace(StringUtils.PATTERNS.WHITESPACE, '') : 
+            propertyName.trim();
     }
 
+    /**
+     * Converts a string value to its appropriate type while preserving data integrity
+     * @param {string} value - The input value to convert
+     * @returns {string|number|boolean} The converted value
+     */
     getValueFormatByType(value) {
-        if(value === undefined || value === ''){
+        if (this.isEmpty(value)) {
             return String();
         }
-        //is Number
-        let isNumber = !isNaN(value);
-        if (isNumber) {
-            return Number(value);
+
+        if (this.isBoolean(value)) {
+            return this.convertToBoolean(value);
+        }
+
+        if (this.isInteger(value)) {
+            return this.convertInteger(value);
         }
-        // is Boolean
-        if(value === "true" || value === "false"){
-            return JSON.parse(value.toLowerCase());
+
+        if (this.isFloat(value)) {
+            return this.convertFloat(value);
         }
+
         return String(value);
     }
 
-    hasContent(values) {
-        if (values.length > 0) {
-            for (let i = 0; i < values.length; i++) {
-                if (values[i]) {
-                    return true;
-                }
-            }
+    /**
+     * Checks if a value array contains any non-empty values
+     * @param {Array} values - Array to check for content
+     * @returns {boolean} True if array has any non-empty values
+     */
+    hasContent(values = []) {
+        return Array.isArray(values) && 
+               values.some(value => Boolean(value));
+    }
+
+    // Private helper methods for type checking and conversion
+    isEmpty(value) {
+        return value === undefined || value === '';
+    }
+
+    isBoolean(value) {
+        const normalizedValue = value.toLowerCase();
+        return normalizedValue === StringUtils.BOOLEAN_VALUES.TRUE || 
+               normalizedValue === StringUtils.BOOLEAN_VALUES.FALSE;
+    }
+
+    isInteger(value) {
+        return StringUtils.PATTERNS.INTEGER.test(value);
+    }
+
+    isFloat(value) {
+        return StringUtils.PATTERNS.FLOAT.test(value);
+    }
+
+    hasLeadingZero(value) {
+        const isPositiveWithLeadingZero = value.length > 1 && value[0] === '0';
+        const isNegativeWithLeadingZero = value.length > 2 && value[0] === '-' && value[1] === '0';
+        return isPositiveWithLeadingZero || isNegativeWithLeadingZero;
+    }
+
+    convertToBoolean(value) {
+        return JSON.parse(value.toLowerCase());
+    }
+
+    convertInteger(value) {
+        if (this.hasLeadingZero(value)) {
+            return String(value);
         }
-        return false;
+
+        const num = Number(value);
+        return Number.isSafeInteger(num) ? num : String(value);
+    }
+
+    convertFloat(value) {
+        const num = Number(value);
+        return Number.isFinite(num) ? num : String(value);
     }
 }