slicejs-web-framework 3.0.0 → 3.1.1

package/.worktrees/public-env-browser-exposure/src/Components/AppComponents/Playground/Playground.js

@@ -0,0 +1,111 @@
+export default class Playground extends HTMLElement {
+   constructor(props) {
+      super();
+      slice.attachTemplate(this);
+
+      slice.controller.setComponentProps(this, props);
+      this.debuggerProps = [];
+   }
+
+   async init() {
+      let theme = slice.stylesManager.themeManager.currentTheme;
+
+      const navBar = await slice.build('Navbar', {
+         // position: "fixed",
+         logo: {
+            src: '/images/Slice.js-logo.png',
+            path: '/',
+         },
+         items: [
+            {
+               text: 'Home',
+               path: '/',
+            },
+            {
+               text: 'Playground',
+               path: '/Playground',
+            },
+         ],
+         buttons: [
+            {
+               value: 'Change Theme',
+               // color:
+               onClickCallback: async () => {
+                  if (theme === 'Slice') {
+                     await slice.setTheme('Light');
+                     theme = 'Light';
+                  } else if (theme === 'Light') {
+                     await slice.setTheme('Dark');
+                     theme = 'Dark';
+                  } else if (theme === 'Dark') {
+                     await slice.setTheme('Slice');
+                     theme = 'Slice';
+                  }
+               },
+            },
+         ],
+      });
+
+      this.appendChild(navBar);
+
+      const sliceButton = await slice.build('Button', {
+         value: 'Slice',
+      });
+      const sliceInput = await slice.build('Input', {
+         placeholder: 'Enter text here...',
+      });
+      const checkbox = await slice.build('Checkbox', {
+         label: 'Check',
+         position: 'top',
+      });
+
+      const sliceSwitch = await slice.build('Switch', {
+         label: 'Switch',
+         labelPlacement: 'left',
+      });
+      const select = await slice.build('Select', {
+         options: [
+            { value: 'Hola', id: 0 },
+            { value: 'Hello', id: 1 },
+            { value: 'Hallo', id: 2 },
+            { value: 'Hi', id: 3 },
+            { value: 'Hola', id: 4 },
+            { value: 'Hello', id: 5 },
+            { value: 'Hallo', id: 6 },
+            { value: 'Hi', id: 7 },
+         ],
+         visibleProp: 'id',
+         label: 'Elige una opcion',
+         multiple: true,
+      });
+      const sliceCard = await slice.build('Card', {
+         sliceId: 'prueba',
+      });
+      const details = await slice.build('Details', {
+         title: 'Slice',
+         text: 'Slice details text',
+      });
+
+      const grid = document.createElement('div');
+      grid.classList.add('indexGrid');
+
+      sliceButton.classList.add('indexGridItem');
+      sliceInput.classList.add('indexGridItem');
+      sliceSwitch.classList.add('indexGridItem');
+      select.classList.add('indexGridItem');
+      checkbox.classList.add('indexGridItem');
+      details.classList.add('indexGridItem');
+
+      grid.appendChild(sliceButton);
+      grid.appendChild(sliceInput);
+      grid.appendChild(sliceSwitch);
+      grid.appendChild(select);
+      grid.appendChild(checkbox);
+      grid.appendChild(sliceCard);
+      grid.appendChild(details);
+
+      this.appendChild(grid);
+   }
+}
+
+customElements.define('slice-playground', Playground);

package/.worktrees/public-env-browser-exposure/src/Components/Service/FetchManager/FetchManager.js

@@ -0,0 +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;
+   }
+}

package/.worktrees/public-env-browser-exposure/src/Components/Service/IndexedDbManager/IndexedDbManager.js

@@ -0,0 +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}`));
+         };
+      });
+   }
+}

package/.worktrees/public-env-browser-exposure/src/Components/Service/LocalStorageManager/LocalStorageManager.js

@@ -0,0 +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;
+      }
+   }
+}

package/.worktrees/public-env-browser-exposure/src/Components/Visual/Button/Button.css

@@ -0,0 +1,47 @@
+.slice_button_container {
+  padding: 10px;
+}
+.slice_button_value {
+  user-select: none;
+  cursor: pointer;
+}
+.slice_button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  overflow: hidden;
+  position: relative;
+  max-width: fit-content;
+  background-color: var(--primary-color);
+  color: var(--primary-color-contrast);
+  border-radius: var(--border-radius-slice);
+  border: var(--slice-border) solid var(--primary-color);
+  font-weight: 800;
+  min-width: 100%;
+  padding: 10px;
+  -webkit-transition-duration: 0.4s; /* Safari */
+  transition-duration: 0.4s;
+}
+.slice_button:after {
+  content: "";
+  width: 100%;
+  height: 100%;
+  border-radius: 100%;
+  background: #ffffff50;
+  position: absolute;
+  display: block;
+  opacity: 0;
+  scale: 10;
+  transition: all 1s;
+}
+.slice_button:active {
+  transform: translateY(5px);
+}
+.slice_button:active:after {
+  scale: 0;
+  padding: 0;
+  margin: 0;
+  opacity: 1;
+  transition: 0s;
+}

package/.worktrees/public-env-browser-exposure/src/Components/Visual/Button/Button.html

@@ -0,0 +1,5 @@
+<div class="slice_button_container">
+  <button class="slice_button">
+    <label class="slice_button_value"></label>
+  </button>
+</div>

package/.worktrees/public-env-browser-exposure/src/Components/Visual/Button/Button.js

@@ -0,0 +1,93 @@
+export default class Button extends HTMLElement {
+
+   static props = {
+      value: { 
+         type: 'string', 
+         default: 'Button', 
+         required: false 
+      },
+      onClickCallback: { 
+         type: 'function', 
+         default: null 
+      },
+      customColor: { 
+         type: 'object', 
+         default: null 
+      },
+      icon: { 
+         type: 'object', 
+         default: null 
+      }
+   };
+
+   constructor(props) {
+      super();
+      slice.attachTemplate(this);
+      this.$value = this.querySelector('.slice_button_value');
+      this.$button = this.querySelector('.slice_button');
+      this.$container = this.querySelector('.slice_button_container');
+      
+      if (props.onClickCallback) {
+         this.onClickCallback = props.onClickCallback;
+         this.$container.addEventListener('click', async () => await this.onClickCallback());
+      }
+
+      slice.controller.setComponentProps(this, props);
+   }
+
+   async init() {
+      if (this.icon) {
+         this.$icon = await slice.build('Icon', {
+            name: this.icon,
+            size: '20px',
+            color: 'currentColor',
+         });
+         this.$button.insertBefore(this.$icon, this.$value);
+      }
+   }
+
+   get icon() {
+      return this._icon;
+   }
+
+   set icon(value) {
+      this._icon = value;
+      if (!this.$icon) return;
+      this.$icon.name = value.name;
+      this.$icon.iconStyle = value.iconStyle;
+   }
+
+   get value() {
+      return this._value;
+   }
+
+   set value(value) {
+      this._value = value;
+      this.$value.textContent = value;
+   }
+
+   get customColor() {
+      return this._customColor;
+   }
+
+   set customColor(value) {
+      this._customColor = value;
+      if (!value) return;
+
+      // Mantener la misma API: { button: 'color', label: 'color' }
+      if (value.button) {
+         this.$button.style.backgroundColor = value.button;
+         this.$button.style.borderColor = value.button;
+      }
+      if (value.label) {
+         this.$button.style.color = value.label;
+         this.$value.style.color = value.label;
+         // También aplicar al icono si existe
+         if (this.$icon) {
+            this.$icon.style.color = value.label;
+         }
+      }
+   }
+}
+
+customElements.define('slice-button', Button);

package/.worktrees/public-env-browser-exposure/src/Components/Visual/Card/Card.css

@@ -0,0 +1,68 @@
+.title {
+  font-size: 20px;
+  font-weight: bold;
+  color: var(--font-primary-color);
+  text-align: center;
+}
+
+.slice-card {
+  height: 220px;
+  position: relative;
+  font-family: var(--font-family);
+  background-color: var(--seconday-background-color);
+  border-radius: var(--border-radius-slice);
+  transition: all 300ms;
+}
+
+.slice-card:hover {
+  .card_cover {
+    height: auto;
+    transform: translateY(-70%);
+    box-shadow: 0px 10px 10px #00000050;
+  }
+  .card_info {
+    height: 100%;
+    transform: translateY(20%);
+    box-shadow: 0px -10px 10px #00000050;
+  }
+}
+.card_cover {
+  width: 100%;
+  height: 90%;
+  background: var(--primary-color);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  position: absolute;
+  z-index: 1;
+  transition: all 400ms ease;
+  border-radius: var(--border-radius-slice);
+}
+
+.card_info {
+  width: 100%;
+  height: 200px;
+  bottom: 0;
+  color: var(--font-secondary-color);
+  background: var(--secondary-background-color);
+  position: absolute;
+  font-size: 20px;
+  transition: all 400ms cubic-bezier(0.5, 0, 0, 1);
+  border-radius: var(--border-radius-slice);
+}
+
+.card_info p {
+  text-align: center;
+  color: var(--font-secondary-color);
+  padding: 0px 20px 20px 20px;
+  font-size: 15px;
+  display: -webkit-box;
+  display: -moz-box;
+  display: box;
+  -webkit-box-orient: vertical;
+  -moz-box-orient: vertical;
+  box-orient: vertical;
+  -webkit-line-clamp: 5;
+  line-clamp: 5;
+  overflow: hidden;
+}

package/.worktrees/public-env-browser-exposure/src/Components/Visual/Card/Card.html

@@ -0,0 +1,7 @@
+<div class="slice-card">
+  <div class="card_cover"></div>
+  <div class="card_info">
+    <h1 class="title">Slice Card Title</h1>
+    <p class="text">Slice Card text</p>
+  </div>
+</div>