slicejs-cli 3.5.1 → 3.6.1

package/tests/e2e/dependency-scenarios.spec.js

@@ -1,56 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-function trackErrors(page) {
-  const errors = [];
-  page.on('console', (m) => m.type() === 'error' && errors.push(m.text()));
-  page.on('pageerror', (e) => errors.push(String(e)));
-  return errors;
-}
-
-test.describe('default-export shared dependency', () => {
-  test('/defaultdep resolves a default export at runtime', async ({ page }) => {
-    const errors = trackErrors(page);
-    await page.goto('/defaultdep');
-
-    await expect(page.locator('slice-defaultdeppage')).toBeAttached();
-    await expect(page.locator('slice-defaultdeppage')).toHaveAttribute('data-cfg-title', 'Configured');
-    await expect(page.locator('slice-defaultdeppage')).toHaveAttribute(
-      'data-cfg-tagline',
-      'default-export-works'
-    );
-
-    expect(errors, `console errors:\n${errors.join('\n')}`).toEqual([]);
-  });
-});
-
-test.describe('component CSS application', () => {
-  test('/cssprobe applies the bundled component stylesheet', async ({ page }) => {
-    const errors = trackErrors(page);
-    await page.goto('/cssprobe');
-
-    const marker = page.locator('slice-cssprobepage .css-probe-marker');
-    await expect(marker).toBeVisible();
-    await expect(marker).toHaveCSS('color', 'rgb(7, 113, 219)');
-    await expect(marker).toHaveCSS('font-weight', '700');
-
-    expect(errors, `console errors:\n${errors.join('\n')}`).toEqual([]);
-  });
-});
-
-test.describe('transitive dependency of a shared module', () => {
-  // mid.js (imported by the component) itself imports leaf.js. The bundler must
-  // recursively inline leaf.js and bind its exports inside mid's scope, or the
-  // page breaks at runtime.
-  test('/transitive renders and the transitively-imported helper works', async ({ page }) => {
-    const errors = trackErrors(page);
-    await page.goto('/transitive');
-
-    await expect(page.locator('slice-transitivepage')).toBeAttached();
-    await expect(page.locator('slice-transitivepage')).toHaveAttribute(
-      'data-transitive',
-      'mid(leaf-value)[leaf:leaf-value]'
-    );
-
-    expect(errors, `console errors:\n${errors.join('\n')}`).toEqual([]);
-  });
-});

package/tests/e2e/fixtures/components/Service/FetchManager/FetchManager.js

@@ -1,136 +0,0 @@
-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) {
-            loading.stop();
-            return this.lastRequest.output;
-         }
-
-         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 once on error; pass false to avoid infinite recursion when
-               // the endpoint keeps failing.
-               return await this.request(
-                  method,
-                  data,
-                  endpoint,
-                  onRequestSuccess,
-                  onRequestError,
-                  false,
-                  requestOptions
-               );
-            }
-         }
-
-         let output = await response.json();
-         loading.stop();
-
-         // Cache the parsed response if cache is enabled
-         if (this.cacheEnabled) {
-            this.lastRequest = { data, output, endpoint };
-         }
-
-         return output;
-      } catch (error) {
-         // slice.logger.logError signature is (componentSliceId, message, error).
-         if (error.message === 'Failed to fetch') {
-            slice.logger.logError('FetchManager', 'Lost internet connection', error);
-         } else {
-            slice.logger.logError('FetchManager', 'Request failed', 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/tests/e2e/fixtures/components/Service/IndexedDbManager/IndexedDbManager.js

@@ -1,149 +0,0 @@
-export default class IndexedDbManager {
-   constructor(props = {}) {
-      // Slice builds services with a single props object, e.g.
-      // slice.build('IndexedDbManager', { databaseName, storeName }). The legacy
-      // positional form `new IndexedDbManager(dbName, storeName)` still works.
-      if (typeof props === 'string') {
-         this.databaseName = props;
-         this.storeName = arguments[1];
-      } else {
-         this.databaseName = props.databaseName;
-         this.storeName = props.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/tests/e2e/fixtures/components/Service/LocalStorageManager/LocalStorageManager.js

@@ -1,45 +0,0 @@
-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/tests/e2e/fixtures/components/Visual/Button/Button.css

@@ -1,106 +0,0 @@
-/* Encapsulated under the custom element so the button styles never leak. */
-
-slice-button .slice_button_container {
-  padding: 10px;
-}
-
-slice-button .slice_button_value {
-  user-select: none;
-  cursor: pointer;
-}
-
-slice-button .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 .slice_button:focus-visible {
-  outline: none;
-  box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary-color) 45%, transparent);
-}
-
-slice-button .slice_button:after {
-  content: "";
-  width: 100%;
-  height: 100%;
-  border-radius: 100%;
-  background: color-mix(in srgb, var(--primary-color-contrast) 32%, transparent);
-  position: absolute;
-  display: block;
-  opacity: 0;
-  scale: 10;
-  transition: all 1s;
-}
-
-slice-button .slice_button:active {
-  transform: translateY(5px);
-}
-
-slice-button .slice_button:active:after {
-  scale: 0;
-  padding: 0;
-  margin: 0;
-  opacity: 1;
-  transition: 0s;
-}
-
-/* ----------------------------------------------------------------- variants
-   Every variant derives from the theme tokens — they automatically follow the
-   active theme. `filled` is the original solid look; the modifiers are declared
-   after the base rule so they win on equal specificity. */
-
-slice-button .slice_button--filled {
-  background-color: var(--primary-color);
-  color: var(--primary-color-contrast);
-  border-color: var(--primary-color);
-}
-
-slice-button .slice_button--outlined {
-  background-color: transparent;
-  color: var(--primary-color);
-  border-color: var(--primary-color);
-}
-
-slice-button .slice_button--ghost {
-  background-color: transparent;
-  color: var(--primary-color);
-  border-color: transparent;
-}
-
-slice-button .slice_button--soft {
-  background-color: color-mix(in srgb, var(--primary-color) 16%, transparent);
-  color: var(--primary-color);
-  border-color: transparent;
-}
-
-/* Hover tint for the non-filled variants */
-slice-button .slice_button--outlined:hover,
-slice-button .slice_button--ghost:hover {
-  background-color: color-mix(in srgb, var(--primary-color) 12%, transparent);
-}
-
-slice-button .slice_button--soft:hover {
-  background-color: color-mix(in srgb, var(--primary-color) 26%, transparent);
-}
-
-/* The ripple flash uses a primary-color tint on the light/transparent variants
-   (the base contrast flash would be invisible on them). */
-slice-button .slice_button--outlined:after,
-slice-button .slice_button--ghost:after,
-slice-button .slice_button--soft:after {
-  background: color-mix(in srgb, var(--primary-color) 22%, transparent);
-}

package/tests/e2e/fixtures/components/Visual/Button/Button.html

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

package/tests/e2e/fixtures/components/Visual/Button/Button.js

@@ -1,158 +0,0 @@
-// Warns once per deprecated prop name (kept module-scoped so each component
-// reports a given alias only once per session).
-const _sliceDeprecated = new Set();
-function deprecate(oldName, newName) {
-   if (_sliceDeprecated.has(oldName)) return;
-   _sliceDeprecated.add(oldName);
-   console.warn(`[Slice] "${oldName}" is deprecated; use "${newName}" instead.`);
-}
-
-export default class Button extends HTMLElement {
-
-   static props = {
-      value: {
-         type: 'string',
-         default: 'Button',
-         required: false
-      },
-      // Visual style, all derived from theme tokens. `filled` preserves the
-      // original solid look.
-      variant: {
-         type: 'string',
-         default: 'filled',
-         required: false,
-         allowedValues: ['filled', 'outlined', 'ghost', 'soft']
-      },
-      // Canonical click handler. `onClickCallback` is kept as a deprecated alias.
-      onClick: {
-         type: 'function',
-         default: null
-      },
-      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');
-
-      // type="button" prevents accidental form submission when used inside a form.
-      this.$button.setAttribute('type', 'button');
-
-      // Listener is attached unconditionally; the handler is resolved at click
-      // time so it works whether it arrived via onClick or the legacy alias.
-      this.$container.addEventListener('click', async () => {
-         if (this._onClick) await this._onClick();
-      });
-
-      slice.controller.setComponentProps(this, props);
-   }
-
-   async init() {
-      if (this.icon) {
-         this.$icon = await slice.build('Icon', {
-            name: this.icon.name,
-            iconStyle: this.icon.iconStyle,
-            size: '20px',
-            color: 'currentColor',
-         });
-         this.$button.insertBefore(this.$icon, this.$value);
-      }
-   }
-
-   get onClick() {
-      return this._onClick;
-   }
-
-   set onClick(value) {
-      if (typeof value === 'function') this._onClick = value;
-   }
-
-   // Deprecated alias for onClick.
-   set onClickCallback(value) {
-      if (typeof value === 'function') {
-         this._onClick ??= value;
-         deprecate('onClickCallback', 'onClick');
-      }
-   }
-
-   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 variant() {
-      return this._variant;
-   }
-
-   set variant(value) {
-      const allowed = ['filled', 'outlined', 'ghost', 'soft'];
-      const next = allowed.includes(value) ? value : 'filled';
-      if (this._variant) {
-         this.$button.classList.remove('slice_button--' + this._variant);
-      }
-      this._variant = next;
-      this.$button.classList.add('slice_button--' + next);
-   }
-
-   get value() {
-      return this._value;
-   }
-
-   set value(value) {
-      this._value = value;
-      this.$value.textContent = value;
-      // Keep an accessible name even for icon-only buttons.
-      if (value) this.$button.setAttribute('aria-label', value);
-   }
-
-   get customColor() {
-      return this._customColor;
-   }
-
-   // Canonical shape: { background, text }. Legacy { button, label } still works.
-   set customColor(value) {
-      this._customColor = value;
-      if (!value) return;
-
-      if (value.button || value.label) {
-         deprecate('customColor { button, label }', 'customColor { background, text }');
-      }
-
-      const background = value.background ?? value.button;
-      const text = value.text ?? value.label;
-
-      if (background) {
-         this.$button.style.backgroundColor = background;
-         this.$button.style.borderColor = background;
-      }
-      if (text) {
-         this.$button.style.color = text;
-         this.$value.style.color = text;
-         if (this.$icon) {
-            this.$icon.style.color = text;
-         }
-      }
-   }
-}
-
-customElements.define('slice-button', Button);

package/tests/e2e/fixtures/components/Visual/Link/Link.js

@@ -1,33 +0,0 @@
-export default class Link extends HTMLElement {
-   constructor(props = {}) {
-      super();
-      this.props = props;
-      this.render(props);
-      this.init();
-   }
-
-   init() {
-      this.addEventListener('click', this.onClick);
-   }
-
-   async onClick(event) {
-      event.preventDefault();
-      const path = this.querySelector('a')?.getAttribute('href');
-      if (path) slice.router.navigate(path);
-   }
-
-   // Built with DOM APIs (setAttribute / textContent) instead of an innerHTML
-   // template so a `path` like `javascript:...` or text containing markup can't
-   // inject into the document.
-   render(props = {}) {
-      const { path = '#', classes = '', text = '' } = props;
-      const anchor = document.createElement('a');
-      anchor.setAttribute('href', path);
-      anchor.setAttribute('data-route', '');
-      if (classes) anchor.className = classes;
-      anchor.textContent = text;
-      this.replaceChildren(anchor);
-   }
-}
-
-customElements.define('slice-link', Link);