devkits-json-formatter 1.0.0 → 1.0.1

package/README.md

@@ -1,45 +1,125 @@
 # @devkits/json-formatter
 
-Format and validate JSON from CLI or stdin. Part of [@devkits/tools](https://devkits-tools.surge.sh).
+[![Part of DevKits](https://img.shields.io/badge/DevKits-82%2B%20Tools-blue)](https://devkits-tools.surge.sh)
 
-## Install
+Format, validate, and minify JSON. Syntax error detection with position info. Zero-dependency JSON utility for developers.
+
+## 🧰 DevKits Pro Tools
+
+This package is part of **DevKits** — 82+ free developer tools. The online JSON Formatter includes schema validation, tree view, and query/filter tools.
+
+**→ [Format JSON with Tree View](https://devkits-tools.surge.sh)**
+
+## Installation
 
 ```bash
-npm install -g @devkits/json-formatter
+npm install @devkits/json-formatter
 ```
 
 ## Usage
 
-### Format JSON (pretty print)
+```javascript
+const {
+  format,
+  minify,
+  isValid,
+  pretty,
+  countKeys,
+  getSizeInfo,
+  sortKeys,
+  formatSorted
+} = require('@devkits/json-formatter');
+
+const uglyJson = '{"name":"John","age":30,"city":"NYC"}';
+
+// Format JSON with indentation
+const result = format(uglyJson, { indent: 2 });
+// {
+//   success: true,
+//   result: '{\n  "name": "John",\n  "age": 30,\n  "city": "NYC"\n}'
+// }
+
+// Minify JSON
+const min = minify(uglyJson);
+// { success: true, result: '{"name":"John",...}', saved: 15 }
+
+// Validate JSON
+isValid('{"valid": true}');
+// { valid: true }
+
+isValid('{invalid}');
+// { valid: false, error: 'Unexpected token...', position: {line: 1, column: 2} }
+
+// Pretty print an object
+pretty({ name: 'John', age: 30 });
+// '{\n  "name": "John",\n  "age": 30\n}'
+
+// Count keys recursively
+const nested = { a: { b: { c: 1 } }, d: [1, 2, 3] };
+countKeys(nested);
+// 5
+
+// Get size info
+getSizeInfo(uglyJson);
+// { original: 36, minified: 36, saved: 0, keys: 3 }
+
+// Sort keys alphabetically
+const unsorted = { z: 1, a: 2, m: 3 };
+sortKeys(unsorted);
+// { a: 2, m: 3, z: 1 }
+
+// Format with sorted keys
+formatSorted('{"z":1,"a":2}', 2);
+// { success: true, result: '{\n  "a": 2,\n  "z": 1\n}' }
+```
 
-```bash
-# From stdin
-echo '{"name":"DevKits","tools":84}' | jsonfmt
+## API
 
-# From file
-jsonfmt package.json
+### `format(jsonString, options)`
+Formats JSON with specified indentation (default: 2 spaces).
 
-# From JSON string
-jsonfmt '{"test":true}'
-```
+Returns `{success, result?, error?}`.
 
-### Minify JSON
+### `minify(jsonString)`
+Removes all whitespace from JSON.
 
-```bash
-jsonfmt package.json --minify
-jsonfmt '{"test":true}' -m
-```
+Returns `{success, result?, error?, saved?}`.
+
+### `isValid(jsonString)`
+Validates JSON syntax with optional error position.
+
+Returns `{valid, error?, position?}`.
+
+### `pretty(obj, indent)`
+Pretty prints a JavaScript object as JSON string.
+
+### `countKeys(obj)`
+Counts all keys in an object recursively.
+
+### `getSizeInfo(jsonString)`
+Returns size statistics: original size, minified size, bytes saved, key count.
+
+### `sortKeys(obj)`
+Returns new object with keys sorted alphabetically (recursive).
+
+### `formatSorted(jsonString, indent)`
+Formats JSON with keys sorted alphabetically.
 
-### Web Version
+## See Also
 
-Use the web version at: https://devkits-tools.surge.sh
+**Free Online Version:** [DevKits - JSON Formatter](https://devkits-tools.surge.sh)
 
-### Pro Features
+### Other DevKits npm Packages
 
-Unlock batch processing, API access, and cloud sync: https://devkits-tools.surge.sh/pro
+| Package | Description |
+|---------|-------------|
+| @devkits/base64-tool | Base64 encoding/decoding |
+| @devkits/csv-json-converter | Convert between CSV and JSON |
+| @devkits/markdown-tools | Markdown utilities |
+| @devkits/env-editor | .env file utilities |
 
-Use code `EARLYBIRD-2026` for 20% off ($7.20 instead of $9).
+**Browse all 82 tools at [DevKits](https://devkits-tools.surge.sh)**
 
 ## License
 
-MIT — DevKits Team
+MIT

package/index.js

@@ -1,93 +1,177 @@
-#!/usr/bin/env node
-
 /**
- * @devkits/json-formatter — Format and validate JSON
+ * @devkits/json-formatter
  *
- * Usage:
- *   jsonfmt <file|json> [--minify]
- *   echo '{"foo":"bar"}' | jsonfmt
- *   jsonfmt package.json
+ * Format, validate, and minify JSON.
+ * Works in both Node.js and browser environments.
  */
 
-const fs = require('fs');
-
-const PRO_UPGRADE = '\n🚀 Want more? Upgrade to Pro: https://devkits-tools.surge.sh/pro\n   Use code EARLYBIRD-2026 for 20% off\n';
-
-function showHelp() {
-  console.log(`
-@devkits/json-formatter — Format and validate JSON
-
-Usage:
-  jsonfmt <file|json> [--minify]
-  jsonfmt package.json
-  jsonfmt '{"foo":"bar"}'
-  echo '{"test":true}' | jsonfmt
-
-Options:
-  --minify, -m    Minify JSON (remove whitespace)
-  --help, -h      Show this help
-
-Examples:
-  jsonfmt package.json
-  jsonfmt '{"foo":"bar"}' --minify
-  cat data.json | jsonfmt
+/**
+ * Format JSON string with indentation
+ * @param {string} jsonString - JSON string to format
+ * @param {Object} options - Format options
+ * @param {number} options.indent - Indentation spaces (default: 2)
+ * @returns {{success: boolean, result?: string, error?: string}}
+ */
+function format(jsonString, options = {}) {
+  const { indent = 2 } = options;
 
-Web Version: https://devkits-tools.surge.sh
-Pro Features: https://devkits-tools.surge.sh/pro
-`);
+  try {
+    const parsed = JSON.parse(jsonString);
+    return {
+      success: true,
+      result: JSON.stringify(parsed, null, indent)
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
 }
 
-function formatJSON(input, minify = false) {
+/**
+ * Minify JSON (remove all whitespace)
+ * @param {string} jsonString - JSON string to minify
+ * @returns {{success: boolean, result?: string, error?: string, saved?: number}}
+ */
+function minify(jsonString) {
   try {
-    let jsonData;
+    const parsed = JSON.parse(jsonString);
+    const minified = JSON.stringify(parsed);
+    return {
+      success: true,
+      result: minified,
+      saved: jsonString.length - minified.length
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
 
-    // Check if input is a file path
-    if (fs.existsSync(input)) {
-      input = fs.readFileSync(input, 'utf-8');
+/**
+ * Validate JSON syntax
+ * @param {string} jsonString - JSON string to validate
+ * @returns {{valid: boolean, error?: string, position?: {line: number, column: number}}}
+ */
+function isValid(jsonString) {
+  try {
+    JSON.parse(jsonString);
+    return { valid: true };
+  } catch (e) {
+    // Try to extract position from error message
+    const posMatch = e.message.match(/position\s+(\d+)/i);
+    let position = null;
+
+    if (posMatch) {
+      const pos = parseInt(posMatch[1], 10);
+      const lines = jsonString.substring(0, pos).split('\n');
+      position = {
+        line: lines.length,
+        column: lines[lines.length - 1].length + 1
+      };
     }
 
-    jsonData = JSON.parse(input);
+    return {
+      valid: false,
+      error: e.message,
+      position
+    };
+  }
+}
 
-    if (minify) {
-      console.log(JSON.stringify(jsonData));
-    } else {
-      console.log(JSON.stringify(jsonData, null, 2));
-      console.log(`\n✅ Valid JSON`);
-    }
+/**
+ * Pretty print a JavaScript object as JSON
+ * @param {any} obj - Object to pretty print
+ * @param {number} [indent=2] - Indentation spaces
+ * @returns {string} Formatted JSON string
+ */
+function pretty(obj, indent = 2) {
+  return JSON.stringify(obj, null, indent);
+}
 
-  } catch (err) {
-    console.error(`❌ Invalid JSON: ${err.message}`);
-    process.exit(1);
+/**
+ * Count keys in a JSON object recursively
+ * @param {any} obj - Object to count keys in
+ * @returns {number} Total key count
+ */
+function countKeys(obj) {
+  if (typeof obj !== 'object' || obj === null) return 0;
+  if (Array.isArray(obj)) {
+    return obj.reduce((n, v) => n + countKeys(v), 0);
   }
+  return Object.keys(obj).reduce((n, k) => n + 1 + countKeys(obj[k]), 0);
 }
 
-// Main
-const args = process.argv.slice(2);
+/**
+ * Get JSON size info
+ * @param {string} jsonString - JSON string
+ * @returns {{original: number, minified?: number, saved?: number, keys?: number}}
+ */
+function getSizeInfo(jsonString) {
+  const info = { original: jsonString.length };
+
+  try {
+    const parsed = JSON.parse(jsonString);
+    info.keys = countKeys(parsed);
+
+    const minified = JSON.stringify(parsed);
+    info.minified = minified.length;
+    info.saved = jsonString.length - minified.length;
+  } catch (e) {
+    // Invalid JSON
+  }
 
-// Check for help
-if (args.includes('--help') || args.includes('-h')) {
-  showHelp();
-  process.exit(0);
+  return info;
 }
 
-const minify = args.includes('--minify') || args.includes('-m');
-const input = args.filter(a => !a.startsWith('-')).join(' ');
+/**
+ * Sort object keys alphabetically
+ * @param {any} obj - Object to sort
+ * @returns {any} Object with sorted keys
+ */
+function sortKeys(obj) {
+  if (obj === null || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(sortKeys);
+
+  const sorted = {};
+  Object.keys(obj).sort().forEach(key => {
+    sorted[key] = sortKeys(obj[key]);
+  });
+  return sorted;
+}
 
-if (!input) {
-  // Read from stdin
+/**
+ * Format with sorted keys
+ * @param {string} jsonString - JSON string
+ * @param {number} [indent=2] - Indentation spaces
+ * @returns {{success: boolean, result?: string, error?: string}}
+ */
+function formatSorted(jsonString, indent = 2) {
   try {
-    const stdin = fs.readFileSync(0, 'utf-8').trim();
-    if (!stdin) {
-      showHelp();
-      process.exit(0);
-    }
-    formatJSON(stdin, minify);
-  } catch (err) {
-    console.error('Error reading stdin: ' + err.message);
-    process.exit(1);
+    const parsed = JSON.parse(jsonString);
+    const sorted = sortKeys(parsed);
+    return {
+      success: true,
+      result: JSON.stringify(sorted, null, indent)
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
   }
-} else {
-  formatJSON(input, minify);
 }
 
-console.log(PRO_UPGRADE);
+module.exports = {
+  format,
+  minify,
+  isValid,
+  pretty,
+  countKeys,
+  getSizeInfo,
+  sortKeys,
+  formatSorted
+};

package/package.json

@@ -1,40 +1,27 @@
 {
   "name": "devkits-json-formatter",
-  "version": "1.0.0",
-  "description": "Format and validate JSON from CLI or stdin — pretty print, minify, and validate JSON files",
+  "version": "1.0.1",
+  "description": "Format, validate, and minify JSON. Syntax error detection with position info. Zero-dependency JSON utility for developers.",
   "main": "index.js",
-  "bin": {
-    "jsonfmt": "./index.js",
-    "json-formatter": "./index.js"
-  },
-  "scripts": {
-    "test": "node test.js"
-  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
   "keywords": [
     "json",
-    "formatter",
-    "validator",
-    "cli",
-    "pretty-print",
-    "minify",
-    "developer-tools"
+    "json-formatter",
+    "json-validator",
+    "json-minifier",
+    "json-beautifier",
+    "json-linter",
+    "developer-tools",
+    "devkits"
   ],
-  "author": "DevKits Team <devkits-auto@protonmail.com>",
+  "author": "DevKits Auto <devkits-auto@protonmail.com>",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/devkits/tools"
-  },
-  "homepage": "https://devkits-tools.surge.sh",
+  "repository": "",
   "bugs": {
-    "url": "https://github.com/devkits/tools/issues"
-  },
-  "engines": {
-    "node": ">=14.0.0"
+    "url": "https://github.com/devkits/devkits/issues"
   },
-  "files": [
-    "index.js",
-    "README.md"
-  ],
-  "dependencies": {}
+  "homepage": "https://devkits-tools.surge.sh"
 }