@terzogenito/json-utils 1.0.8 → 1.0.10

package/README.md

@@ -1 +1,431 @@
-# json-utils
+# Documentation
+
+## Overview
+This module provides various functions for reading, validating, and processing JSON files and URL content.
+
+## Installation
+```bash
+npm install @terzogenito/json-utils
+```
+
+## Function List
+
+### 1. `getData(path)`
+```javascript
+console.log(await app.getData('./test-data.json'));
+```
+
+**Description**: Reads and returns data from a file asynchronously.
+
+**Parameters**:
+- `path` (String): Path to the file to be read
+
+---
+
+### 2. `getString(path)`
+```javascript
+console.log(app.getString('test-data.json'));
+```
+
+**Description**: Reads a file and returns its content as a string.
+
+**Parameters**:
+- `path` (String): Path to the file to be read
+
+---
+
+### 3. `getFile(path, callback)`
+```javascript
+app.getFile('test-data.json', data => {
+    console.log(app.isValid(data));
+});
+```
+
+**Description**: Reads a file and processes the data using a callback function.
+
+**Parameters**:
+- `path` (String): Path to the file to be read
+- `callback` (Function): Function to be called with the file data
+
+---
+
+### 4. `isValid(data)`
+```javascript
+app.getFile('test-data.json', data => {
+    console.log(app.isValid(data));
+});
+```
+
+**Description**: Validates whether the data is valid JSON.
+
+**Parameters**:
+- `data` (Any): Data to be validated
+
+---
+
+### 5. `toString(data)`
+```javascript
+app.getFile('test-data.json', data => {
+    console.log(app.toString(data));
+});
+```
+
+**Description**: Converts JSON data to a string.
+
+**Parameters**:
+- `data` (Object): JSON data to be converted
+
+---
+
+### 6. `readJSON(jsonString)`
+```javascript
+console.log(app.readJSON('{"name":"John","age":30,"isActive":true}'));
+```
+
+**Description**: Reads and parses a JSON string into a JavaScript object.
+
+**Parameters**:
+- `jsonString` (String): JSON string to be parsed
+
+---
+
+### 7. `isJSON(jsonString)`
+```javascript
+console.log(app.isJSON('{"name":"John","age":30,"isActive":true}'));
+```
+
+**Description**: Checks if a string is valid JSON.
+
+**Parameters**:
+- `jsonString` (String): String to be checked
+
+---
+
+### 8. `isJSONObject(obj)`
+```javascript
+console.log(app.isJSONObject({"name": "John","age": 30,"isActive": true}));
+```
+
+**Description**: Checks if an object is a valid JSON object.
+
+**Parameters**:
+- `obj` (Object): Object to be checked
+
+---
+
+### 9. `beautifyJSON(jsonString, indent)`
+```javascript
+console.log(app.beautifyJSON(jsonString));
+console.log(app.beautifyJSON(jsonString, 4));
+```
+
+**Description**: Formats a JSON string with customizable indentation.
+
+**Parameters**:
+- `jsonString` (String): JSON string to be formatted
+- `indent` (Number, optional): Number of spaces for indentation (default: 2)
+
+---
+
+### 10. `beautify(jsonObject)`
+```javascript
+console.log(app.beautify(sampleJSONObject));
+```
+
+**Description**: Formats a JSON object into a readable string.
+
+**Parameters**:
+- `jsonObject` (Object): JSON object to be formatted
+
+---
+
+### 11. `getURL(url, callback)`
+```javascript
+app.getURL("https://example.com/data.txt", data => {
+    console.log(data);
+});
+```
+
+**Description**: Fetches string content from a URL.
+
+**Parameters**:
+- `url` (String): Target URL
+- `callback` (Function): Callback function that receives the data
+
+---
+
+### 12. `getJSON(url, callback)`
+```javascript
+app.getJSON("https://example.com/data.json", data => {
+    console.log(data);
+});
+```
+
+**Description**: Fetches and parses JSON content from a URL.
+
+**Parameters**:
+- `url` (String): URL pointing to JSON file
+- `callback` (Function): Callback function that receives JSON data
+
+## Usage Examples
+
+```javascript
+const app = require('./index');
+
+// Reading local file
+const data = await app.getData('./data.json');
+
+// Validating JSON
+const isValid = app.isJSON('{"key": "value"}');
+
+// Formatting JSON
+const beautified = app.beautifyJSON('{"key":"value"}', 4);
+
+// Fetching data from URL
+app.getJSON("https://api.example.com/data", jsonData => {
+    console.log(jsonData);
+});
+```
+
+### 13. getAttributes(jsonObject)
+```javascript
+const dataJSON = app.readJSON(data);
+const attributes = app.getAttributes(dataJSON);
+// Output: ['name', 'age', 'isActive', 'address', 'hobbies']
+```
+
+**Description**: Extracts all attribute/keys from a JSON object and returns them as an array.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Array of attribute names
+
+### 14. getMeta(jsonObject)
+```javascript
+const meta = app.getMeta(dataJSON);
+// Output: {"name": "string", "age": "integer", "isActive": "boolean"}
+```
+
+**Description**: Generates metadata showing attribute names and their data types.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Object with attribute names as keys and data types as values
+
+Data Types Identified:
+- string, integer, float, boolean, array, object, null, date
+
+### 15. getMetaDetail(jsonObject)
+```javascript
+const metaDetail = app.getMetaDetail(dataJSON);
+// Output: Detailed metadata including nested structures
+```
+
+**Description**: Generates comprehensive metadata including nested attributes, data types, paths, and structural information.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Object with detailed metadata for each attribute
+
+Metadata Includes:
+- type: Data type
+- isRequired: Whether attribute exists
+- path: Full path to attribute
+- children: Nested attributes (for objects)
+- length: Array length (for arrays)
+- elementType: Type of array elements
+
+### 16. getMetaCompact(jsonObject)
+```javascript
+const metaCompact = app.getMetaCompact(dataJSON);
+// Output: Compact metadata format
+```
+
+**Description**: Creates a compact metadata representation showing the structure hierarchy.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Compact representation of JSON structure
+
+Format Examples:
+- "array[string]": Array of strings
+- "array[object]": Array of objects
+- Nested objects shown as nested objects
+
+### 17. getPartial(jsonObject, attributes)
+```javascript
+const partial = app.getPartial(dataJSON, ["name", "age"]);
+// Output: {"name": "John", "age": 30}
+```
+
+**Description**: Extracts specific attributes from a JSON object.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributes (Array|String|Object): Attributes to extract
+
+attribute Parameter Types:
+- Array: List of attribute names to extract
+```javascript
+app.getPartial(data, ["name", "age"])
+```
+- String: Single attribute name
+```javascript
+app.getPartial(data, "name")
+```
+- Object: Mapping of new names to original attributes
+```javascript
+app.getPartial(data, {"fullName": "name", "yearsOld": "age"})
+```
+
+Returns: Object containing only the specified attributes
+
+### 18. getPartialDeep(jsonObject, attributePaths)
+```javascript
+const deepPartial = app.getPartialDeep(dataJSON, ["name", "address.city", "hobbies.length"]);
+// Output: {"name": "John", "city": "Jakarta", "length": 2}
+```
+
+**Description**: Extracts attributes using nested paths (dot notation).
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributePaths (Array|Object): Paths to extract
+
+attributePaths Parameter Types:
+- Array: List of dot-notated paths
+```javascript
+app.getPartialDeep(data, ["user.profile.name", "user.contact.email"])
+```
+- Object: Mapping of new names to paths
+```javascript
+app.getPartialDeep(data, {"userName": "user.profile.name", "userEmail": "user.contact.email"})
+```
+
+Returns: Object with extracted values (uses last path segment as key for array input)
+
+### 19. getPartialWithDefaults(jsonObject, attributesConfig)
+```javascript
+const partialWithDefaults = app.getPartialWithDefaults(dataJSON, {
+"name": "name",
+"status": {
+path: "isActive",
+transform: (val) => val ? "Active" : "Inactive"
+},
+"email": {
+path: "contact.email",
+default: "no-email@example.com"
+}
+});
+```
+
+**Description**: Extracts attributes with advanced configuration including default values and transformations.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributesConfig (Object): Configuration object
+
+Configuration Options:
+- String: Simple path extraction
+```javascript
+"name": "user.fullName"
+```
+- Object: Advanced configuration
+```javascript
+"formattedAge": {
+path: "age", // Required: Path to attribute
+default: 0, // Optional: Default value if path doesn't exist
+transform: (val) => ${val} years old // Optional: Transformation function
+}
+```
+
+Returns: Object with extracted and processed values
+
+### 20. excludeAttributes(jsonObject, attributesToExclude)
+```javascript
+const filtered = app.excludeAttributes(dataJSON, ["isActive", "address"]);
+// Output: {"name": "John", "age": 30, "hobbies": ["reading", "coding"]}
+```
+
+**Description**: Creates a new JSON object excluding specified attributes.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributesToExclude (Array|String): Attributes to remove
+
+attributesToExclude Parameter Types:
+- Array: List of attribute names to exclude
+```javascript
+app.excludeAttributes(data, ["password", "secretKey"])
+```
+- String: Single attribute name to exclude
+```javascript
+app.excludeAttributes(data, "password")
+```
+
+Returns: New object without the excluded attributes
+
+### 21. getAttributeValue(jsonObject, attributeName, defaultValue)
+```javascript
+const name = app.getAttributeValue(dataJSON, "name");
+const email = app.getAttributeValue(dataJSON, "email", "default@email.com");
+```
+
+**Description**: Gets the value of a specific attribute with optional default value.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributeName (String): Name of the attribute to retrieve
+- defaultValue (Any, optional): Default value if attribute doesn't exist
+
+Returns: Attribute value or default value
+
+Advanced Usage Examples
+```javascript
+const app = require('./index');
+
+// Get all attributes from JSON
+const data = await app.getData('./data.json');
+const jsonData = app.readJSON(data);
+const attributes = app.getAttributes(jsonData);
+
+// Get metadata information
+const meta = app.getMeta(jsonData);
+const metaDetail = app.getMetaDetail(jsonData);
+
+// Extract specific data
+const userInfo = app.getPartial(jsonData, ["name", "email", "phone"]);
+const nestedData = app.getPartialDeep(jsonData, ["user.profile.name", "user.contact.email"]);
+
+// Extract with transformations and defaults
+const processedData = app.getPartialWithDefaults(jsonData, {
+"fullName": "user.name",
+"ageFormatted": {
+path: "user.age",
+transform: (age) => ${age} years old
+},
+"country": {
+path: "user.address.country",
+default: "Unknown"
+}
+});
+
+// Exclude sensitive information
+const safeData = app.excludeAttributes(jsonData, ["password", "ssn", "creditCard"]);
+
+// Analyze complex nested structures
+const complexMeta = app.getMetaDetail(complexJSON);
+console.log(complexMeta.user?.children?.contact?.children?.email?.type); // "string"
+
+// Get single attribute value
+const userName = app.getAttributeValue(jsonData, "name");
+const userEmail = app.getAttributeValue(jsonData, "email", "no-email@example.com");
+```
+
+## Requirements
+- Node.js 12 or higher
+- Internet connection (for URL functions)

package/index.js

@@ -1,4 +1,67 @@
-const fileUtils = require('@terzogenito/file-utils');
+const fs = require('fs');
+const https = require('https');
+
+function getString(filePath) {
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+function getFile(filePath, callback) {
+  fs.readFile(filePath, 'utf8', (err, data) => {
+    if (err) {
+      return;
+    } else {
+      callback(data);
+    }
+  });
+}
+
+function loadFile(filePath) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(filePath, 'utf8', (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data);
+      }
+    });
+  });
+}
+
+async function getData(filePath) {
+  try {
+    const data = await loadFile(filePath);
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function getURL(url, callback) {
+  https.get(url, (response) => {
+    let data = '';
+    response.on('data', chunk => {
+      data += chunk;
+    });
+    response.on('end', () => {
+      callback(data || null);
+    });
+  }).on('error', (err) => {
+    callback(null);
+  });
+}
+
+function isUrl(input) {
+  const urlPattern = /^(https?:\/\/|ftp:\/\/|www\.)/i;
+  return urlPattern.test(input);
+}
+
+function getContent(target, callback) {
+  if (isUrl(target)) {
+    getURL(target, callback);
+  } else {
+    getFile(target, callback);
+  }
+}
 
 function readJSON(jsonString) {
   return JSON.parse(jsonString);
@@ -12,8 +75,7 @@ function isValid(jsonString) {
   try {
     JSON.parse(jsonString);
     return true;
-  } catch (error) {
-    console.log("The string is not valid JSON.");
+  } catch {
     return false;
   }
 }
@@ -27,30 +89,427 @@ function isJSON(jsonObject) {
   }
 }
 
+function isJSONObject(jsonObject) {
+  try {
+    return typeof jsonObject === 'object' && jsonObject !== null && jsonObject !== undefined;
+  } catch (error) {
+    return false;
+  }
+}
+
 function getJSON(target, callback) {
-  fileUtils.getContent(target, data => {
-    if (isValid(data)) {
+  getContent(target, data => {
+    if (!data) {
+      return callback(null);
+    }
+    if (!isValid(data)) {
+      return callback(null);
+    }
+    try {
       callback(readJSON(data));
+    } catch {
+      callback(null);
     }
   });
 }
 
-function beautifyJSON(jsonString, indent) {
+function beautifyJSON(jsonString, indent = 2) {
   try {
+    if (typeof jsonString !== 'string') return null;
     const jsonObject = JSON.parse(jsonString);
+    return JSON.stringify(jsonObject, null, indent);
+  } catch {
+    return null;
+  }
+}
+
+function beautify(jsonObject, indent) {
+  try {
     if (!indent) indent = 2;
     return JSON.stringify(jsonObject, null, indent);
   } catch (error) {
-    console.error("Invalid JSON string:", error);
     return null;
   }
 }
 
+function getAttributes(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return [];
+    }
+
+    return Object.keys(jsonObject);
+  } catch (error) {
+    return [];
+  }
+}
+
+function getMeta(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const meta = {};
+
+    for (const [key, value] of Object.entries(jsonObject)) {
+      let type = typeof value;
+
+      if (type === 'object') {
+        if (value === null) {
+          type = 'null';
+        } else if (Array.isArray(value)) {
+          type = 'array';
+        } else if (value instanceof Date) {
+          type = 'date';
+        } else {
+          type = 'object';
+        }
+      } else if (type === 'number') {
+        type = Number.isInteger(value) ? 'integer' : 'float';
+      }
+      
+      meta[key] = type;
+    }
+    
+    return meta;
+  } catch (error) {
+    return {};
+  }
+}
+
+function getMetaDetail(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+
+    function getNestedMeta(obj, path = '') {
+      const meta = {};
+      
+      for (const [key, value] of Object.entries(obj)) {
+        const currentPath = path ? `${path}.${key}` : key;
+        const attributeMeta = {};
+
+        let type = typeof value;
+
+        if (value === null) {
+          type = 'null';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = false;
+          attributeMeta.path = currentPath;
+        } else if (Array.isArray(value)) {
+          type = 'array';
+          attributeMeta.type = type;
+          attributeMeta.length = value.length;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+
+          if (value.length > 0) {
+            const firstElement = value[0];
+            const elementType = typeof firstElement;
+            
+            if (elementType === 'object' && firstElement !== null) {
+              if (Array.isArray(firstElement)) {
+                attributeMeta.elementType = 'array';
+              } else {
+                attributeMeta.elementType = 'object';
+                attributeMeta.children = getNestedMeta(firstElement, `${currentPath}[0]`);
+              }
+            } else {
+              attributeMeta.elementType = elementType;
+            }
+          } else {
+            attributeMeta.elementType = 'unknown';
+          }
+        } else if (value instanceof Date) {
+          type = 'date';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+        } else if (type === 'object') {
+          type = 'object';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+          attributeMeta.keysCount = Object.keys(value).length;
+
+          attributeMeta.children = getNestedMeta(value, currentPath);
+        } else {
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+
+          if (type === 'number') {
+            attributeMeta.numberType = Number.isInteger(value) ? 'integer' : 'float';
+          }
+        }
+
+        meta[key] = attributeMeta;
+      }
+      
+      return meta;
+    }
+    
+    return getNestedMeta(jsonObject);
+  } catch (error) {
+    console.error('Error in getMetaDetail:', error);
+    return {};
+  }
+}
+
+function getMetaCompact(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+
+    function getCompactMeta(obj) {
+      const meta = {};
+      
+      for (const [key, value] of Object.entries(obj)) {
+        let type = typeof value;
+        
+        if (value === null) {
+          meta[key] = 'null';
+        } else if (Array.isArray(value)) {
+          if (value.length > 0) {
+            const firstElement = value[0];
+            const elementType = typeof firstElement;
+            if (elementType === 'object' && firstElement !== null) {
+              meta[key] = `array[${Array.isArray(firstElement) ? 'array' : 'object'}]`;
+            } else {
+              meta[key] = `array[${elementType}]`;
+            }
+          } else {
+            meta[key] = 'array[]';
+          }
+        } else if (value instanceof Date) {
+          meta[key] = 'date';
+        } else if (type === 'object') {
+          meta[key] = getCompactMeta(value);
+        } else if (type === 'number') {
+          meta[key] = Number.isInteger(value) ? 'integer' : 'float';
+        } else {
+          meta[key] = type;
+        }
+      }
+      
+      return meta;
+    }
+    
+    return getCompactMeta(jsonObject);
+  } catch (error) {
+    console.error('Error in getMetaCompact:', error);
+    return {};
+  }
+}
+
+function getPartial(jsonObject, attributes) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    if (Array.isArray(attributes)) {
+      for (const attr of attributes) {
+        if (attr in jsonObject) {
+          result[attr] = jsonObject[attr];
+        }
+      }
+    }
+    else if (typeof attributes === 'string') {
+      if (attributes in jsonObject) {
+        result[attributes] = jsonObject[attributes];
+      }
+    }
+    else if (typeof attributes === 'object' && attributes !== null) {
+      for (const [newKey, originalKey] of Object.entries(attributes)) {
+        if (originalKey in jsonObject) {
+          result[newKey] = jsonObject[originalKey];
+        }
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartial:', error);
+    return {};
+  }
+}
+
+function getPartialDeep(jsonObject, attributePaths) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    function getValueFromPath(obj, path) {
+      const parts = path.split('.');
+      let current = obj;
+      
+      for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+          current = current[part];
+        } else {
+          return undefined;
+        }
+      }
+      
+      return current;
+    }
+
+    if (Array.isArray(attributePaths)) {
+      for (const path of attributePaths) {
+        const value = getValueFromPath(jsonObject, path);
+        if (value !== undefined) {
+          const key = path.split('.').pop();
+          result[key] = value;
+        }
+      }
+    }
+    else if (typeof attributePaths === 'object' && attributePaths !== null) {
+      for (const [newKey, path] of Object.entries(attributePaths)) {
+        const value = getValueFromPath(jsonObject, path);
+        if (value !== undefined) {
+          result[newKey] = value;
+        }
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartialDeep:', error);
+    return {};
+  }
+}
+
+function getPartialWithDefaults(jsonObject, attributesConfig) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    function getValueFromPath(obj, path, defaultValue) {
+      const parts = path.split('.');
+      let current = obj;
+      
+      for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+          current = current[part];
+        } else {
+          return defaultValue;
+        }
+      }
+      
+      return current;
+    }
+
+    for (const [outputKey, config] of Object.entries(attributesConfig)) {
+      if (typeof config === 'string') {
+        result[outputKey] = getValueFromPath(jsonObject, config, undefined);
+      } else if (typeof config === 'object' && config !== null) {
+        const path = config.path || outputKey;
+        const defaultValue = config.default;
+        let value = getValueFromPath(jsonObject, path, defaultValue);
+
+        if (config.transform && typeof config.transform === 'function') {
+          value = config.transform(value);
+        }
+        
+        result[outputKey] = value;
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartialWithDefaults:', error);
+    return {};
+  }
+}
+
+function excludeAttributes(jsonObject, attributesToExclude) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = { ...jsonObject };
+
+    if (Array.isArray(attributesToExclude)) {
+      for (const attr of attributesToExclude) {
+        delete result[attr];
+      }
+    }
+    else if (typeof attributesToExclude === 'string') {
+      delete result[attributesToExclude];
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in excludeAttributes:', error);
+    return {};
+  }
+}
+
 module.exports = {
+  getString,
+  getFile,
+  getData,
+  getURL,
+  getContent,
   readJSON,
   toString,
   isValid,
   isJSON,
+  isJSONObject,
   getJSON,
   beautifyJSON,
-};
+  beautify,
+  getAttributes,
+  getMeta,
+  getMetaDetail,
+  getMetaCompact,
+  getPartial,
+  getPartialDeep,
+  getPartialWithDefaults,
+  excludeAttributes,
+};

package/package.json

@@ -1,31 +1,39 @@
-{
-  "name": "@terzogenito/json-utils",
-  "version": "1.0.8",
-  "description": "Check JSON Format",
-  "main": "index.js",
-  "files": [
-    "index.js"
-  ],
-  "scripts": {
-    "start": "node test.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=21.6.1"
-  },
-  "keywords": [
-    "nodejs",
-    "module",
-    "json",
-    "check",
-    "utils"
-  ],
-  "author": "Terzogenito",
-  "license": "MIT",
-  "dependencies": {
-    "@terzogenito/file-utils": "^1.0.0"
-  }
-}
+{
+  "name": "@terzogenito/json-utils",
+  "version": "1.0.10",
+  "description": "JSON data utilities",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "start": "node test.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=21.6.1"
+  },
+  "keywords": [
+    "nodejs",
+    "module",
+    "utils",
+    "tools",
+    "json",
+    "check",
+    "beautify",
+    "analysis"
+  ],
+  "author": "Terzogenito",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/terzogenito/json-utils.git"
+  },
+  "homepage": "https://github.com/terzogenito/json-utils#readme",
+  "bugs": {
+    "url": "https://github.com/terzogenito/json-utils/issues"
+  }
+}