slicejs-web-framework 2.4.7 → 3.0.0

package/.worktrees/bundling-v2-precompiled-registrars/src/Components/AppComponents/HomePage/HomePage.html

@@ -0,0 +1,37 @@
+<div class="home-page-container">
+
+  <section class="hero-section">
+    <div class="hero-content">
+      <div class="hero-badge">v2.4 · Vanilla JS Framework</div>
+      <h1 class="hero-title">Build your web app<br>one <span class="highlight">Slice</span> at a time</h1>
+      <p class="hero-sub">A lightweight, component-based framework for building web applications with vanilla JavaScript and web standards.</p>
+      <div class="hero-cta"></div>
+      <div class="hero-chips">
+        <span class="hero-chip">Button</span>
+        <span class="hero-chip">Input</span>
+        <span class="hero-chip">Switch</span>
+        <span class="hero-chip">Navbar</span>
+        <span class="hero-chip">Grid</span>
+        <span class="hero-chip">Card</span>
+        <span class="hero-chip">+ more</span>
+      </div>
+    </div>
+  </section>
+
+  <section class="features-section">
+    <div class="section-header">
+      <p class="section-label">Why Slice.js</p>
+      <h2 class="section-title">Everything you need, nothing you don't</h2>
+    </div>
+    <div class="feature-grid"></div>
+  </section>
+
+  <section class="showcase-section">
+    <div class="section-header">
+      <p class="section-label">Component Showcase</p>
+      <h2 class="section-title">Ready-to-use components</h2>
+    </div>
+    <div class="showcase-grid"></div>
+  </section>
+
+</div>

package/.worktrees/bundling-v2-precompiled-registrars/src/Components/AppComponents/HomePage/HomePage.js

@@ -0,0 +1,210 @@
+export default class HomePage extends HTMLElement {
+   constructor(props) {
+      super();
+      slice.attachTemplate(this);
+      slice.controller.setComponentProps(this, props);
+      this.debuggerProps = [];
+   }
+
+   async init() {
+      await Promise.all([
+         this._buildNavbar(),
+         this._buildHeroCta(),
+         this._buildFeatures(),
+         this._buildShowcase(),
+      ]);
+   }
+
+   async _buildNavbar() {
+      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',
+               onClickCallback: async () => {
+                  const current = slice.stylesManager.themeManager.currentTheme;
+                  const next = current === 'Slice' ? 'Light'
+                             : current === 'Light' ? 'Dark'
+                             : 'Slice';
+                  await slice.setTheme(next);
+               },
+            },
+         ],
+      });
+      this.insertBefore(navbar, this.firstChild);
+   }
+
+   async _buildHeroCta() {
+      const docsBtn = await slice.build('Button', {
+         value: 'Documentation',
+         onClickCallback: () =>
+            window.open('https://slice-js-docs.vercel.app/Documentation', '_blank'),
+         customColor: {
+            button: 'var(--primary-color)',
+            label: 'var(--primary-color-contrast)',
+         },
+      });
+
+      const componentsBtn = await slice.build('Button', {
+         value: 'Components Library',
+         onClickCallback: () =>
+            window.open('https://slice-js-docs.vercel.app/Documentation/Visual', '_blank'),
+         customColor: {
+            button: 'var(--secondary-background-color)',
+            label: 'var(--primary-color)',
+         },
+      });
+
+      const cta = this.querySelector('.hero-cta');
+      cta.appendChild(docsBtn);
+      cta.appendChild(componentsBtn);
+   }
+
+   async _buildFeatures() {
+      const features = [
+         {
+            title: 'Component-Based',
+            description: 'Build your app using modular, reusable components following web standards.',
+         },
+         {
+            title: 'Themeable',
+            description: 'Swap themes at runtime. Ships with Slice, Light, Dark and more.',
+         },
+         {
+            title: 'Lightweight',
+            description: 'No heavy runtime. Just vanilla JavaScript and web standards.',
+         },
+         {
+            title: 'Built-in Router',
+            description: 'Client-side routing with MultiRoute — no extra libraries needed.',
+         },
+         {
+            title: 'CLI Tools',
+            description: 'Scaffold projects, create components and build bundles from the command line.',
+         },
+         {
+            title: 'Services',
+            description: 'Built-in FetchManager, LocalStorage and IndexedDB integrations.',
+         },
+      ];
+
+      const grid = this.querySelector('.feature-grid');
+      for (const { title, description } of features) {
+         const item = document.createElement('div');
+         item.classList.add('feature-item');
+
+         const h3 = document.createElement('h3');
+         h3.classList.add('feature-title');
+         h3.textContent = title;
+
+         const p = document.createElement('p');
+         p.classList.add('feature-description');
+         p.textContent = description;
+
+         item.appendChild(h3);
+         item.appendChild(p);
+         grid.appendChild(item);
+      }
+   }
+
+   async _buildShowcase() {
+      const grid = this.querySelector('.showcase-grid');
+
+      // Helper: wrap built components in a labeled card and append to grid
+      const addCard = (label, ...components) => {
+         const card = document.createElement('div');
+         card.classList.add('comp-card');
+
+         const labelEl = document.createElement('p');
+         labelEl.classList.add('comp-label');
+         labelEl.textContent = label;
+
+         const demo = document.createElement('div');
+         demo.classList.add('comp-demo');
+         components.forEach(c => demo.appendChild(c));
+
+         card.appendChild(labelEl);
+         card.appendChild(demo);
+         grid.appendChild(card);
+      };
+
+      // Button — primary + secondary variants
+      const [btnPrimary, btnSecondary] = await Promise.all([
+         slice.build('Button', {
+            value: 'Primary',
+            onClickCallback: () => {},
+            customColor: {
+               button: 'var(--primary-color)',
+               label: 'var(--primary-color-contrast)',
+            },
+         }),
+         slice.build('Button', {
+            value: 'Secondary',
+            onClickCallback: () => {},
+            customColor: {
+               button: 'var(--secondary-background-color)',
+               label: 'var(--primary-color)',
+            },
+         }),
+      ]);
+      addCard('Button', btnPrimary, btnSecondary);
+
+      // Input
+      const input = await slice.build('Input', {
+         placeholder: 'Type something...',
+         type: 'text',
+      });
+      addCard('Input', input);
+
+      // Switch
+      const sw = await slice.build('Switch', {
+         label: 'Toggle me',
+         checked: true,
+      });
+      addCard('Switch', sw);
+
+      // Select — theme chooser
+      const themeOptions = [
+         { name: 'Slice Theme' },
+         { name: 'Light Theme' },
+         { name: 'Dark Theme' },
+         { name: 'Purple Theme' },
+      ];
+      const select = await slice.build('Select', {
+         label: 'Pick a theme',
+         options: themeOptions,
+         visibleProp: 'name',
+         onOptionSelect: async (option) => {
+            if (!option) return;
+            const themeName = option.name.replace(' Theme', '');
+            await slice.setTheme(themeName);
+         },
+      });
+      addCard('Select', select);
+
+      // Loading — triggered by a demo button (Loading appends to document.body)
+      const loading = await slice.build('Loading', {});
+      const demoBtn = await slice.build('Button', {
+         value: 'Demo Loading',
+         onClickCallback: () => {
+            loading.start();
+            setTimeout(() => loading.stop(), 1500);
+         },
+         customColor: {
+            button: 'var(--primary-color)',
+            label: 'var(--primary-color-contrast)',
+         },
+      });
+      addCard('Loading', demoBtn);
+   }
+}
+
+customElements.define('slice-home-page', HomePage);

package/.worktrees/bundling-v2-precompiled-registrars/src/Components/AppComponents/Playground/Playground.css

@@ -0,0 +1,12 @@
+.indexGrid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    grid-template-rows: repeat(1, 1fr);
+    gap: 10px;
+    margin: 0 auto;
+  }
+  .indexGridItem {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }

package/.worktrees/bundling-v2-precompiled-registrars/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/bundling-v2-precompiled-registrars/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/bundling-v2-precompiled-registrars/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/bundling-v2-precompiled-registrars/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;
+      }
+   }
+}