slicejs-web-framework 2.3.4 → 2.4.0

package/src/Components/Service/FetchManager/FetchManager.js

@@ -1,133 +1,133 @@
-export default class FetchManager {
-   constructor(props) {
-      const { baseUrl, timeout } = props;
-      if (baseUrl !== undefined) {
-         this.baseUrl = baseUrl;
-      }
-      this.methods = ['GET', 'POST', 'PUT', 'DELETE'];
-      this.lastRequest = null;
-      this.cacheEnabled = false;
-      this.defaultHeaders = {};
-      timeout ? (this.timeout = timeout) : (this.timeout = 10000);
-   }
-
-   async request(
-      method,
-      data,
-      endpoint,
-      onRequestSuccess,
-      onRequestError,
-      refetchOnError = false,
-      requestOptions = {}
-   ) {
-      if (!this.methods.includes(method)) throw new Error('Invalid method');
-      if (data && typeof data !== 'object') throw new Error('Invalid data, not JSON');
-      const controller = new AbortController();
-
-      let options;
-      if (method !== 'GET') {
-         options = {
-            method: method,
-            headers: {
-               'Content-Type': 'application/json',
-               ...this.defaultHeaders,
-               ...requestOptions.headers,
-            },
-            signal: controller.signal,
-         };
-      } else {
-         options = {
-            method: method,
-            headers: {
-               ...this.defaultHeaders,
-               ...requestOptions.headers,
-            },
-            signal: controller.signal,
-         };
-      }
-
-      if (data) {
-         options.body = JSON.stringify(data);
-      }
-
-      let loading;
-      if (!slice.controller.getComponent('Loading')) {
-         loading = await slice.build('Loading', { sliceId: 'Loading' });
-      } else {
-         loading = slice.controller.getComponent('Loading');
-      }
-      loading.start();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout || 10000);
-
-      try {
-         let response;
-
-         // Check if cache is enabled and a cached response exists
-         if (this.cacheEnabled && this.lastRequest && this.lastRequest.endpoint === endpoint) {
-            return this.lastRequest.response;
-         }
-
-         if (this.baseUrl !== undefined) {
-            response = await fetch(this.baseUrl + endpoint, options);
-         } else {
-            response = await fetch(endpoint, options);
-         }
-
-         if (response.ok) {
-            if (typeof onRequestSuccess === 'function') {
-               onRequestSuccess(data, response);
-            }
-         } else {
-            if (typeof onRequestError === 'function') {
-               onRequestError(data, response);
-            }
-            if (refetchOnError) {
-               // Retry the request in case of error
-               return await this.request(
-                  method,
-                  data,
-                  endpoint,
-                  onRequestSuccess,
-                  onRequestError,
-                  refetchOnError,
-                  requestOptions
-               );
-            }
-         }
-
-         let output = await response.json();
-         loading.stop();
-
-         // Cache the response if cache is enabled
-         if (this.cacheEnabled) {
-            this.lastRequest = { data, response, endpoint };
-         }
-
-         return output;
-      } catch (error) {
-         if (error.message === 'Failed to fetch') {
-            slice.logger.logError('Se perdió la conexión a internet');
-         } else {
-            console.error('Error al realizar la solicitud:', error);
-         }
-         loading.stop();
-         throw error;
-      } finally {
-         clearTimeout(timeoutId);
-      }
-   }
-
-   // Enable or disable caching of responses
-   enableCache() {
-      this.cacheEnabled = true;
-   }
-
-   disableCache() {
-      this.cacheEnabled = false;
-   }
-
-   // Set default headers for all requests
-   setDefaultHeaders(headers) {
-      this.defaultHeaders = headers;
-   }
-}
+export default class FetchManager {
+   constructor(props) {
+      const { baseUrl, timeout } = props;
+      if (baseUrl !== undefined) {
+         this.baseUrl = baseUrl;
+      }
+      this.methods = ['GET', 'POST', 'PUT', 'DELETE'];
+      this.lastRequest = null;
+      this.cacheEnabled = false;
+      this.defaultHeaders = {};
+      timeout ? (this.timeout = timeout) : (this.timeout = 10000);
+   }
+
+   async request(
+      method,
+      data,
+      endpoint,
+      onRequestSuccess,
+      onRequestError,
+      refetchOnError = false,
+      requestOptions = {}
+   ) {
+      if (!this.methods.includes(method)) throw new Error('Invalid method');
+      if (data && typeof data !== 'object') throw new Error('Invalid data, not JSON');
+      const controller = new AbortController();
+
+      let options;
+      if (method !== 'GET') {
+         options = {
+            method: method,
+            headers: {
+               'Content-Type': 'application/json',
+               ...this.defaultHeaders,
+               ...requestOptions.headers,
+            },
+            signal: controller.signal,
+         };
+      } else {
+         options = {
+            method: method,
+            headers: {
+               ...this.defaultHeaders,
+               ...requestOptions.headers,
+            },
+            signal: controller.signal,
+         };
+      }
+
+      if (data) {
+         options.body = JSON.stringify(data);
+      }
+
+      let loading;
+      if (!slice.controller.getComponent('Loading')) {
+         loading = await slice.build('Loading', { sliceId: 'Loading' });
+      } else {
+         loading = slice.controller.getComponent('Loading');
+      }
+      loading.start();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout || 10000);
+
+      try {
+         let response;
+
+         // Check if cache is enabled and a cached response exists
+         if (this.cacheEnabled && this.lastRequest && this.lastRequest.endpoint === endpoint) {
+            return this.lastRequest.response;
+         }
+
+         if (this.baseUrl !== undefined) {
+            response = await fetch(this.baseUrl + endpoint, options);
+         } else {
+            response = await fetch(endpoint, options);
+         }
+
+         if (response.ok) {
+            if (typeof onRequestSuccess === 'function') {
+               onRequestSuccess(data, response);
+            }
+         } else {
+            if (typeof onRequestError === 'function') {
+               onRequestError(data, response);
+            }
+            if (refetchOnError) {
+               // Retry the request in case of error
+               return await this.request(
+                  method,
+                  data,
+                  endpoint,
+                  onRequestSuccess,
+                  onRequestError,
+                  refetchOnError,
+                  requestOptions
+               );
+            }
+         }
+
+         let output = await response.json();
+         loading.stop();
+
+         // Cache the response if cache is enabled
+         if (this.cacheEnabled) {
+            this.lastRequest = { data, response, endpoint };
+         }
+
+         return output;
+      } catch (error) {
+         if (error.message === 'Failed to fetch') {
+            slice.logger.logError('Se perdió la conexión a internet');
+         } else {
+            console.error('Error al realizar la solicitud:', error);
+         }
+         loading.stop();
+         throw error;
+      } finally {
+         clearTimeout(timeoutId);
+      }
+   }
+
+   // Enable or disable caching of responses
+   enableCache() {
+      this.cacheEnabled = true;
+   }
+
+   disableCache() {
+      this.cacheEnabled = false;
+   }
+
+   // Set default headers for all requests
+   setDefaultHeaders(headers) {
+      this.defaultHeaders = headers;
+   }
+}

package/src/Components/Service/IndexedDbManager/IndexedDbManager.js

@@ -1,141 +1,141 @@
-export default class IndexedDbManager {
-   constructor(databaseName, storeName) {
-      this.databaseName = databaseName;
-      this.storeName = storeName;
-      this.db = null;
-   }
-
-   async openDatabase() {
-      return new Promise((resolve, reject) => {
-         const request = indexedDB.open(this.databaseName);
-
-         request.onupgradeneeded = (event) => {
-            const db = event.target.result;
-            if (!db.objectStoreNames.contains(this.storeName)) {
-               db.createObjectStore(this.storeName, {
-                  keyPath: 'id',
-                  autoIncrement: true,
-               });
-            }
-         };
-
-         request.onsuccess = (event) => {
-            this.db = event.target.result;
-            resolve(this.db);
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error opening IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   closeDatabase() {
-      if (this.db) {
-         this.db.close();
-         this.db = null;
-      }
-   }
-
-   async addItem(item) {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readwrite');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.add(item);
-
-         request.onsuccess = () => {
-            resolve(request.result);
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error adding item to IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   async updateItem(item) {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readwrite');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.put(item);
-
-         request.onsuccess = () => {
-            resolve(request.result);
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error updating item in IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   async getItem(id) {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readonly');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.get(id);
-
-         request.onsuccess = () => {
-            resolve(request.result);
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error getting item from IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   async deleteItem(id) {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readwrite');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.delete(id);
-
-         request.onsuccess = () => {
-            resolve();
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error deleting item from IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   async getAllItems() {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readonly');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.getAll();
-
-         request.onsuccess = () => {
-            resolve(request.result);
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error getting items from IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-
-   async clearItems() {
-      const db = await this.openDatabase();
-      return new Promise((resolve, reject) => {
-         const transaction = db.transaction([this.storeName], 'readwrite');
-         const store = transaction.objectStore(this.storeName);
-         const request = store.clear();
-
-         request.onsuccess = () => {
-            resolve();
-         };
-
-         request.onerror = (event) => {
-            reject(new Error(`Error clearing items in IndexedDB: ${event.target.error}`));
-         };
-      });
-   }
-}
+export default class IndexedDbManager {
+   constructor(databaseName, storeName) {
+      this.databaseName = databaseName;
+      this.storeName = storeName;
+      this.db = null;
+   }
+
+   async openDatabase() {
+      return new Promise((resolve, reject) => {
+         const request = indexedDB.open(this.databaseName);
+
+         request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            if (!db.objectStoreNames.contains(this.storeName)) {
+               db.createObjectStore(this.storeName, {
+                  keyPath: 'id',
+                  autoIncrement: true,
+               });
+            }
+         };
+
+         request.onsuccess = (event) => {
+            this.db = event.target.result;
+            resolve(this.db);
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error opening IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   closeDatabase() {
+      if (this.db) {
+         this.db.close();
+         this.db = null;
+      }
+   }
+
+   async addItem(item) {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readwrite');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.add(item);
+
+         request.onsuccess = () => {
+            resolve(request.result);
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error adding item to IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   async updateItem(item) {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readwrite');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.put(item);
+
+         request.onsuccess = () => {
+            resolve(request.result);
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error updating item in IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   async getItem(id) {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readonly');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.get(id);
+
+         request.onsuccess = () => {
+            resolve(request.result);
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error getting item from IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   async deleteItem(id) {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readwrite');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.delete(id);
+
+         request.onsuccess = () => {
+            resolve();
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error deleting item from IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   async getAllItems() {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readonly');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.getAll();
+
+         request.onsuccess = () => {
+            resolve(request.result);
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error getting items from IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+
+   async clearItems() {
+      const db = await this.openDatabase();
+      return new Promise((resolve, reject) => {
+         const transaction = db.transaction([this.storeName], 'readwrite');
+         const store = transaction.objectStore(this.storeName);
+         const request = store.clear();
+
+         request.onsuccess = () => {
+            resolve();
+         };
+
+         request.onerror = (event) => {
+            reject(new Error(`Error clearing items in IndexedDB: ${event.target.error}`));
+         };
+      });
+   }
+}

package/src/Components/Service/LocalStorageManager/LocalStorageManager.js

@@ -1,45 +1,45 @@
-export default class LocalStorageManager {
-   constructor() {
-      // No se necesitan propiedades en este caso
-   }
-
-   getItem(key) {
-      try {
-         const item = localStorage.getItem(key);
-         return item ? JSON.parse(item) : null;
-      } catch (error) {
-         console.error(`Error getting item from localStorage: ${error.message}`);
-         return null;
-      }
-   }
-
-   setItem(key, value) {
-      try {
-         localStorage.setItem(key, JSON.stringify(value));
-         return true;
-      } catch (error) {
-         console.error(`Error setting item in localStorage: ${error.message}`);
-         return false;
-      }
-   }
-
-   removeItem(key) {
-      try {
-         localStorage.removeItem(key);
-         return true;
-      } catch (error) {
-         console.error(`Error removing item from localStorage: ${error.message}`);
-         return false;
-      }
-   }
-
-   clear() {
-      try {
-         localStorage.clear();
-         return true;
-      } catch (error) {
-         console.error(`Error clearing localStorage: ${error.message}`);
-         return false;
-      }
-   }
-}
+export default class LocalStorageManager {
+   constructor() {
+      // No se necesitan propiedades en este caso
+   }
+
+   getItem(key) {
+      try {
+         const item = localStorage.getItem(key);
+         return item ? JSON.parse(item) : null;
+      } catch (error) {
+         console.error(`Error getting item from localStorage: ${error.message}`);
+         return null;
+      }
+   }
+
+   setItem(key, value) {
+      try {
+         localStorage.setItem(key, JSON.stringify(value));
+         return true;
+      } catch (error) {
+         console.error(`Error setting item in localStorage: ${error.message}`);
+         return false;
+      }
+   }
+
+   removeItem(key) {
+      try {
+         localStorage.removeItem(key);
+         return true;
+      } catch (error) {
+         console.error(`Error removing item from localStorage: ${error.message}`);
+         return false;
+      }
+   }
+
+   clear() {
+      try {
+         localStorage.clear();
+         return true;
+      } catch (error) {
+         console.error(`Error clearing localStorage: ${error.message}`);
+         return false;
+      }
+   }
+}