slicejs-web-framework 1.0.5 → 1.0.7

package/src/Components/AppComponents/TheSliceTeam/TheSliceTeam.js

@@ -0,0 +1,129 @@
+export default class TheSliceTeam extends HTMLElement {
+  constructor(props) {
+     super();
+     slice.attachTemplate(this);
+
+     this.$container = this.querySelector('.slice_team_container');
+     this.$title = this.querySelector('.slice_team_title');
+
+     slice.controller.setComponentProps(this, props);
+     this.debuggerProps = ['members'];
+  }
+
+  async init() {
+
+
+
+   const navBar = await slice.build('Navbar', {
+      position: 'fixed',
+      logo: {
+         src: '../../images/Slice.js-logo.png',
+         path: '/',
+      },
+      items: [
+         {
+            text: 'Home',
+            path: '/',
+         },
+         {
+            text: 'Documentation',
+            path: '/Documentation',
+         },
+         {
+            text: 'Playground',
+            path: '/Playground',
+         },
+         {
+            text: 'Our Team',
+            path: '/Team',
+         }
+
+      ],
+      buttons: [
+         {
+            value: 'Change Theme',
+            // color:
+            onClickCallback: async () => {
+
+               let theme = slice.stylesManager.themeManager.currentTheme;
+               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 Victor = {
+      name: "Victor Kneider",
+      role: "Founder. Lead Developer. Software Architect.",
+      image:"https://avatars.githubusercontent.com/u/103617388?v=4",
+      description: "Computer Engineer passionate and ethusiast about technology and Component-Based Development. He is the creator of Slice.js and the main developer of the project.",
+      links: [
+         {label: "Github", href: "https://github.com/VKneider" },
+         {label: "Linkedin", href:"https://www.linkedin.com/in/vkneider/"}
+      ]
+   
+       
+
+      
+    }
+
+
+    const Julio = {
+      name: "Julio Graterol",
+      role: "Frontend Developer. Visual Components Library Creator and Designer",
+      image:"https://avatars.githubusercontent.com/u/99130732?v=4",
+      //julio is a frontend developer and designer, he is the creator of the visual components library and the designer of the Slice.js logo and website.
+      description: "Frontend Developer and Designer. He is the creator of the Visual Components Library and the designer of the Slice.js logo and website.",
+      links: [
+         {label: "Github", href: "https://github.com/juliograterol"},
+         {label: "Linkedin", href:"https://www.linkedin.com/in/julio-graterol-187589289/"}
+      ]
+
+     
+    }
+
+    const members = [Victor, Julio];  
+
+    await this.addMembers(members);
+     
+  }
+
+  async addMembers(members) {
+     for (let i = 0; i < members.length; i++) {
+        await this.addMember(members[i]);
+     }
+  }
+
+  async addMember(member) {
+     const card = await slice.build('SliceTeamCard', {
+        name: member.name,
+        role: member.role,
+        image: member.image,
+        description: member.description,
+        links: member.links
+     });
+     this.$container.appendChild(card);
+  }
+
+  get members() {
+     return this._members;
+  }
+
+  set members(values) {
+     this._members = values;
+  }
+}
+
+window.customElements.define('slice-team', TheSliceTeam);

package/src/Components/AppComponents/WhatIsSlice/WhatIsSlice.html

@@ -0,0 +1,7 @@
+<h1>What is Slice-js?</h1>
+<p>Slice.js is a web framework designed to simplify the creation of complex applications with straightforward code, enabling both novice and experienced developers to quickly advance in building web applications.
+</p>
+<p>The framework is built on a component-based architecture, allowing developers to construct web applications in a modular way by creating reusable components that can be utilized across different projects. Slice.js also provides a library of pre-built components to streamline the development process.
+</p>
+<p>In addition to this, Slice.js offers features like theming, routing, frontend component debugging, file structure organization, and other functionalities that help make web development more efficient and manageable.
+</p>

package/src/Components/AppComponents/WhatIsSlice/WhatIsSlice.js

@@ -0,0 +1,15 @@
+export default class WhatIsSlice extends HTMLElement {
+  constructor(props) {
+    super();
+    slice.attachTemplate(this);
+
+    slice.controller.setComponentProps(this, props);
+    this.debuggerProps = [];
+  }
+
+  init() {}
+
+  
+}
+
+customElements.define("slice-whatisslice", WhatIsSlice);

package/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/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/src/Components/Service/Link/Link.js

@@ -0,0 +1,26 @@
+export default class Link extends HTMLElement {
+   constructor(props = {}) {
+      super();
+      this.props = props;
+      this.innerHTML = this.getTemplate(props);
+      this.init();
+   }
+
+   init() {
+      this.addEventListener('click', this.onClick);
+   }
+
+   async onClick(event) {
+      event.preventDefault();
+      const path = this.querySelector('a').getAttribute('href');
+      const routeTargets = document.querySelectorAll('slice-routetarget');
+      slice.router.navigate(path);
+   }
+
+   getTemplate(props = {}) {
+      const { path = '#', classes = '', text = '' } = props;
+      return `<a href="${path}" class="${classes}" data-route>${text}</a>`;
+   }
+}
+
+customElements.define('slice-link', Link);

package/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/src/Components/Service/Translator/Translator.js

@@ -0,0 +1,45 @@
+import messages from './messages.json' with { type: 'json' };
+
+export default class Translator {
+   constructor() {
+      this.messages = messages;
+      this.currentLanguage = 'en';
+
+      if (slice.translator) {
+         throw new Error('Translator already initialized');
+      } else {
+         slice.translator = this;
+      }
+   }
+
+   changeLanguage(newLanguage) {
+      this.currentLanguage = newLanguage;
+      return this.setPropertiesForComponents();
+   }
+
+   setPropertiesForComponents() {
+      try {
+         const currentLanguageMessages = this.messages[this.currentLanguage];
+
+         for (const componentName in currentLanguageMessages) {
+            const component = slice.controller.activeComponents.get(componentName);
+            const translations = currentLanguageMessages[componentName];
+            if (component) {
+               for (const prop in translations) {
+                  component[prop] = translations[prop];
+               }
+            } else {
+               console.error(`Component ${componentName} not found`);
+            }
+         }
+
+         return true;
+      } catch (error) {
+         console.log(error);
+      }
+   }
+
+   setMessages(messagesObject) {
+      this.messages = messagesObject;
+   }
+}

package/src/Components/Service/Translator/messages.json

@@ -0,0 +1,58 @@
+{
+    "en": {
+        "myInput": {
+            "placeholder": "Type here"
+        },
+        "cardYoutube": {
+            "title": "Youtube in English",
+            "text": "Youtube is a video sharing platform. You can watch videos, upload your own videos and comment on videos."
+        },
+        "cardGoogle": {
+            "title": "Google in English",
+            "text": "Google is a search engine. You can search for information, images, videos and much more."
+        },
+        "cardFacebook": {
+            "title": "Facebook in English",
+            "text": "Facebook is a social network. You can share photos, videos, statuses and chat with your friends."
+        },
+        "cardTwitter": {
+            "title": "Twitter in English",
+            "text": "Twitter is a social network. You can share tweets, follow other people and stay informed."
+        },
+        "buttonLanguage": {
+            "value": "Change language"
+        },
+        "prueba":{
+            "title":"Card in English",
+            "text":"Text in english"
+        }
+    },
+    "es": {
+        "myInput": {
+            "placeholder": "Escribe aquí"
+        },
+        "cardYoutube": {
+            "title": "Youtube en Español",
+            "text": "Youtube es una plataforma de intercambio de videos. Puedes ver videos, subir tus propios videos y comentar en videos."
+        },
+        "cardGoogle": {
+            "title": "Google en Español",
+            "text": "Google es un motor de búsqueda. Puedes buscar información, imágenes, videos y mucho más."
+        },
+        "cardFacebook": {
+            "title": "Facebook en Español",
+            "text": "Facebook es una red social. Puedes compartir fotos, videos, estados y chatear con tus amigos."
+        },
+        "cardTwitter": {
+            "title": "Twitter en Español",
+            "text": "Twitter es una red social. Puedes compartir tweets, seguir a otras personas y mantenerte informado."
+        },
+        "buttonLanguage": {
+            "value": "Cambiar idioma"
+        },
+        "prueba":{
+            "title":"Card en espanol",
+            "text":"Text en espanol"
+        }
+    }
+}

package/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/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>