safe-try-with-ai 1.1.0 → 1.2.0

package/README.md

@@ -8,7 +8,7 @@ A lightweight JavaScript utility for **clean error handling** with optional **AI
 
 ```bash
 npm install safe-try-with-ai
-
+```
 
 ## Usage
 
@@ -24,6 +24,7 @@ if (err) {
 } else {
   console.log(result); // { x: 1 }
 }
+```
 
 ## Optional AI Runtime Suggestions
 
@@ -39,6 +40,7 @@ if (err) {
   console.log("Suggestion:", err.suggestion); // AI suggestion
   console.log("Fix:", err.fix);               // Suggested fix
 }
+```
 
 ## Features
 
@@ -47,3 +49,22 @@ if (err) {
 - Optional AI-style runtime error suggestions  
 - Zero dependencies  
 - Lightweight and fast
+
+
+## License
+
+MIT
+
+
+## Changelog
+
+### v1.2.0
+- Added `safeTryDefault` for fallback values
+- Added `safeTryJson` for safe JSON parsing
+- Improved AI-style runtime suggestions
+- No breaking changes
+
+### v1.1.1
+- Improved JSON error suggestions
+
+---

package/package.json

@@ -1,18 +1,18 @@
 {
-  "name": "safe-try-with-ai",
-  "version": "1.1.0",
-  "description": "Clean error handling for JavaScript",
-  "keywords": [
-    "error-handling",
-    "utility",
-    "functional",
-    "AI"
-  ],
-  "license": "MIT",
-  "author": "madhuka2002",
-  "type": "commonjs",
-  "main": "src/index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  }
-}
+    "name": "safe-try-with-ai",
+    "version": "1.2.0",
+    "description": "Clean error handling for JavaScript",
+    "keywords": [
+        "error-handling",
+        "utility",
+        "functional",
+        "AI"
+    ],
+    "license": "MIT",
+    "author": "madhuka2002",
+    "type": "commonjs",
+    "main": "src/index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    }
+}

package/src/index.js

@@ -1,92 +1,95 @@
-// src/index.js
+function safeTry(fn, options = {}) {
+    try {
+        const result = fn();
+        return [null, result];
+    } catch (error) {
+        if (options.analyze) {
+            return [analyzeError(error), null];
+        }
+        return [error, null];
+    }
+}
 
-/**
- * Rule-based AI-style error analyzer
- * Returns enriched error object with suggestion and optional fix
- */
-function analyzeError(error) {
-  // Handle undefined variable
-  if (/undefined/.test(error.message)) {
-    return {
-      name: error.name,
-      message: error.message,
-      suggestion: "Check if the variable exists before accessing it",
-      fix: "Use optional chaining (?.) or input validation"
-    };
-  }
+async function safeTryAsync(fn, options = {}) {
+    try {
+        const result = await fn();
+        return [null, result];
+    } catch (error) {
+        if (options.analyze) {
+            return [analyzeError(error), null];
+        }
+        return [error, null];
+    }
+}
 
-  // Handle property access errors
-  if (/Cannot read property/.test(error.message)) {
-    return {
-      name: error.name,
-      message: error.message,
-      suggestion: "Verify the object exists before accessing its property",
-      fix: "Use optional chaining (?.) or null checks"
-    };
-  }
 
-  // Handle JSON parsing errors
-  if (/JSON/.test(error.message)) {
-    return {
-      name: error.name,
-      message: error.message,
-      suggestion: "Check your JSON syntax",
-      fix: "Use JSON validators or wrap JSON.parse in safeTry"
-    };
-  }
+function safeTryDefault(fn, defaultValue, options = {}) {
+    try {
+        const result = fn();
+        return [null, result];
+    } catch (error) {
+        if (options.analyze) {
+            return [analyzeError(error), defaultValue];
+        }
+        return [error, defaultValue];
+    }
+}
 
-  // Handle fetch/network errors
-  if (/fetch/.test(error.message)) {
-    return {
-      name: error.name,
-      message: error.message,
-      suggestion: "Check network connection and URL validity",
-      fix: "Ensure network is online and URL is correct"
-    };
-  }
 
-  // Default fallback
-  return {
-    name: error.name,
-    message: error.message,
-    suggestion: "Check stack trace and input values",
-  };
+function safeTryJson(jsonString, options = {}) {
+    return safeTry(() => JSON.parse(jsonString), options);
 }
 
-/**
- * Safe synchronous try wrapper
- * @param {Function} fn - Function to execute
- * @param {Object} options - { analyze: boolean } optional runtime suggestions
- * @returns {[Error|null, any]} tuple of error and result
- */
-function safeTry(fn, options = {}) {
-  try {
-    const result = fn();
-    return [null, result];
-  } catch (error) {
-    if (options.analyze) {
-      return [analyzeError(error), null];
+
+function analyzeError(error) {
+    const message = error.message || "";
+
+    if (/undefined/.test(message)) {
+        return {
+            name: error.name,
+            message,
+            suggestion: "Check if the variable exists before accessing it",
+            fix: "Use optional chaining or input validation"
+        };
     }
-    return [error, null];
-  }
-}
 
-/**
- * Safe asynchronous try wrapper
- * @param {Function} fn - Async function to execute
- * @param {Object} options - { analyze: boolean } optional runtime suggestions
- * @returns {Promise<[Error|null, any]>} tuple of error and result
- */
-async function safeTryAsync(fn, options = {}) {
-  try {
-    const result = await fn();
-    return [null, result];
-  } catch (error) {
-    if (options.analyze) {
-      return [analyzeError(error), null];
+    if (/Unexpected token|Expected.*position/.test(message)) {
+        return {
+            name: error.name,
+            message,
+            suggestion: "Your JSON appears to be invalid",
+            fix: "Check for missing commas, quotes, or brackets"
+        };
     }
-    return [error, null];
-  }
+
+    if (error instanceof TypeError) {
+        return {
+            name: error.name,
+            message,
+            suggestion: "A value is being used with the wrong type",
+            fix: "Verify variable types before using them"
+        };
+    }
+
+    if (error instanceof ReferenceError) {
+        return {
+            name: error.name,
+            message,
+            suggestion: "A variable is not defined",
+            fix: "Declare the variable before using it"
+        };
+    }
+
+    return {
+        name: error.name,
+        message,
+        suggestion: "Check stack trace and input values"
+    };
 }
 
-module.exports = { safeTry, safeTryAsync };
+module.exports = {
+    safeTry,
+    safeTryAsync,
+    safeTryDefault,
+    safeTryJson
+};