use-fetch-error 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,20 @@
+# Use-fetch-error
+
+## A library for error handling with [error, result] tuples using a `useFetchError()` function.
+
+### Example usage:
+
+```javascript
+(async () => {
+  const validURL = "https://jsonplaceholder.typicode.com/posts/1";
+  const invalidURL = "https://url-invalid.com";
+
+  const [error, data] = await useFetchError(invalidURL);
+
+  if (error) {
+    console.error("An error occurred:", error);
+  } else {
+    console.log("Data received:", data);
+  }
+})();
+```

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "use-fetch-error",
-  "version": "1.0.0",
+  "version": "1.0.1",
+  "description": "A library for error handling with [error, result] tuples using a useFetch() function.",
+  "keywords": [
+    "javascript",
+    "fetch",
+    "handle error"
+  ],
+  "author": "llatzer",
+  "license": "MIT",
   "main": "src/index.js",
   "browser": "src/index.js"
 }

package/src/index.js

@@ -1,103 +1,58 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFetchError = useFetchError;
-var symbol = Symbol("result");
-Function.prototype[symbol] = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    try {
-        var result = this.apply(this, args);
-        return [null, result];
-    }
-    catch (error) {
-        return [error, undefined];
-    }
+const symbolResult = Symbol("result");
+
+/**
+ * Extiende el prototipo de `Function` para incluir un método
+ * que maneja errores y devuelve una tupla `[error, result]`.
+ *
+ * @param {...any[]} args - Los argumentos que se pasarán a la función.
+ * @returns {[any, any]} Una tupla con `null` y el resultado si la función se ejecuta correctamente,
+ * o el error y `undefined` si ocurre una excepción.
+ */
+Function.prototype[symbolResult] = function (...args) {
+  try {
+    const result = this.apply(this, args);
+    return [null, result];
+  } catch (error) {
+    return [error, undefined];
+  }
 };
-Promise.prototype[symbol] = function () {
-    return __awaiter(this, void 0, void 0, function () {
-        var result, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, this];
-                case 1:
-                    result = _a.sent();
-                    return [2 /*return*/, [null, result]];
-                case 2:
-                    error_1 = _a.sent();
-                    return [2 /*return*/, [error_1, undefined]];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+
+/**
+ * Extiende el prototipo de `Promise` para incluir un método
+ * que maneja errores de promesas y devuelve una tupla `[error, result]`.
+ *
+ * @returns {Promise<[any, any]>} Una promesa que se resuelve con una tupla que contiene `null` y el resultado
+ * si la promesa se resuelve correctamente, o el error y `undefined` si es rechazada.
+ */
+Promise.prototype[symbolResult] = async function () {
+  try {
+    const result = await this;
+    return [null, result];
+  } catch (error) {
+    return [error, undefined];
+  }
 };
+
 /**
- * Fetches a URL and handles both network errors and JSON parsing errors.
+ * Realiza una solicitud HTTP utilizando `fetch` y maneja tanto los errores de red como los de parseo JSON.
  *
- * @template T - The expected data type of the parsed JSON response.
- * @param {string} url - The URL to fetch.
- * @param {RequestInit} [options={}] - Optional configuration for the fetch request.
- * @returns {Promise<[any, T | undefined]>} A promise that resolves with a tuple containing either the error and `undefined` if something went wrong, or `null` and the parsed JSON data if successful.
+ * @param {string} url - La URL a la que se hará la solicitud.
+ * @param {RequestInit} [options={}] - Opciones opcionales para configurar la solicitud `fetch`.
+ * @returns {Promise<[any, any]>} Una promesa que se resuelve con una tupla que contiene el error y `undefined` si ocurre un error,
+ * o `null` y los datos parseados si la solicitud y el parseo del JSON son exitosos.
  */
-function useFetchError(url_1) {
-    return __awaiter(this, arguments, void 0, function (url, options) {
-        var _a, error, response, _b, parseError, data;
-        if (options === void 0) { options = {}; }
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, fetch(url, options)[symbol]()];
-                case 1:
-                    _a = _c.sent(), error = _a[0], response = _a[1];
-                    if (error) {
-                        return [2 /*return*/, [error, undefined]]; // Retorna el error si ocurrió
-                    }
-                    return [4 /*yield*/, response.json()[symbol]()];
-                case 2:
-                    _b = _c.sent(), parseError = _b[0], data = _b[1];
-                    if (parseError) {
-                        return [2 /*return*/, [parseError, undefined]]; // Retorna el error al parsear el JSON
-                    }
-                    return [2 /*return*/, [null, data]]; // Retorna el resultado si todo fue bien
-            }
-        });
-    });
+async function useFetchError(url, options = {}) {
+  const [error, response] = await fetch(url, options)[symbolResult]();
+
+  if (error) {
+    return [error, undefined]; // Retorna el error si ocurrió
+  }
+
+  const [parseError, data] = await response.json()[symbolResult]();
+
+  if (parseError) {
+    return [parseError, undefined]; // Retorna el error al parsear el JSON
+  }
+
+  return [null, data]; // Retorna el resultado si todo fue bien
 }