safe-try-with-ai 1.1.1 → 1.3.0

package/README.md

@@ -55,4 +55,16 @@ if (err) {
 
 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/index.d.ts

@@ -0,0 +1,39 @@
+export interface AISuggestion {
+  name: string;
+  message: string;
+  suggestion?: string;
+  fix?: string;
+}
+
+export interface SafeTryOptions {
+  analyze?: boolean;
+}
+
+export type SafeTryResult<T> = [null, T] | [Error | AISuggestion, null];
+
+export function safeTry<T>(
+  fn: () => T,
+  options?: SafeTryOptions
+): SafeTryResult<T>;
+
+export function safeTryAsync<T>(
+  fn: () => Promise<T>,
+  options?: SafeTryOptions
+): Promise<SafeTryResult<T>>;
+
+/**
+ * Safely parse JSON with AI-style error suggestions
+ */
+export function safeTryJson<T = unknown>(
+  json: string,
+  options?: SafeTryOptions
+): SafeTryResult<T>;
+
+/**
+ * Execute with a default fallback value on error
+ */
+export function safeTryDefault<T>(
+  fn: () => T,
+  defaultValue: T,
+  options?: SafeTryOptions
+): T;

package/package.json

@@ -1,18 +1,19 @@
 {
-  "name": "safe-try-with-ai",
-  "version": "1.1.1",
-  "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.3.0",
+    "description": "Clean error handling for JavaScript",
+    "keywords": [
+        "error-handling",
+        "utility",
+        "functional",
+        "AI"
+    ],
+    "license": "MIT",
+    "author": "madhuka2002",
+    "type": "commonjs",
+    "main": "src/index.js",
+    "types": "index.d.ts",
+    "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
+};