valtech-components 2.0.821 → 2.0.823

package/esm2022/lib/services/skeleton/templates/profile-skeleton.component.mjs

@@ -0,0 +1,207 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SkeletonComponent } from '../../../components/atoms/skeleton/skeleton.component';
+import * as i0 from "@angular/core";
+/**
+ * Template de skeleton para perfiles de usuario.
+ *
+ * @example
+ * <val-skeleton-profile></val-skeleton-profile>
+ *
+ * @example
+ * <val-skeleton-profile [config]="{ variant: 'full' }"></val-skeleton-profile>
+ */
+export class ProfileSkeletonComponent {
+    constructor() {
+        this.config = {};
+    }
+    get avatarSize() {
+        return this.config.variant === 'full' ? '96px' : '48px';
+    }
+    get nameWidth() {
+        return this.config.variant === 'full' ? '180px' : '160px';
+    }
+    get subtitleWidth() {
+        return this.config.variant === 'full' ? '140px' : '120px';
+    }
+    get stats() {
+        return [1, 2, 3];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProfileSkeletonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ProfileSkeletonComponent, isStandalone: true, selector: "val-skeleton-profile", inputs: { config: "config" }, ngImport: i0, template: `
+    <div
+      class="skeleton-profile"
+      [class]="'variant-' + (config.variant || 'default') + ' ' + (config.cssClass || '')"
+    >
+      <div class="profile-header">
+        <!-- Avatar -->
+        <val-skeleton
+          [props]="{
+            type: 'avatar',
+            width: avatarSize,
+            height: avatarSize,
+            animated: config.animated !== false
+          }"
+        ></val-skeleton>
+
+        <div class="profile-info">
+          <!-- Name -->
+          <val-skeleton
+            [props]="{
+              type: 'text',
+              width: nameWidth,
+              height: '20px',
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+          <!-- Subtitle -->
+          <val-skeleton
+            [props]="{
+              type: 'text',
+              width: subtitleWidth,
+              height: '14px',
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+          @if (config.variant === 'full') {
+            <!-- Extra info -->
+            <val-skeleton
+              [props]="{
+                type: 'text',
+                width: '100px',
+                height: '12px',
+                animated: config.animated !== false
+              }"
+            ></val-skeleton>
+          }
+        </div>
+      </div>
+
+      @if (config.variant === 'full') {
+        <div class="profile-details">
+          <val-skeleton
+            [props]="{
+              type: 'paragraph',
+              lines: 3,
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+
+          <div class="profile-stats">
+            @for (stat of stats; track $index) {
+              <div class="stat-item">
+                <val-skeleton
+                  [props]="{
+                    type: 'text',
+                    width: '40px',
+                    height: '24px',
+                    animated: config.animated !== false
+                  }"
+                ></val-skeleton>
+                <val-skeleton
+                  [props]="{
+                    type: 'text',
+                    width: '60px',
+                    height: '12px',
+                    animated: config.animated !== false
+                  }"
+                ></val-skeleton>
+              </div>
+            }
+          </div>
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".skeleton-profile{width:100%;&.variant-default .profile-header{display:flex;align-items:center;gap:12px}&.variant-full{.profile-header{display:flex;flex-direction:column;align-items:center;gap:16px;text-align:center}.profile-info{align-items:center}.profile-details{margin-top:24px}}}.profile-info{display:flex;flex-direction:column;gap:6px}.profile-stats{display:flex;justify-content:center;gap:32px;margin-top:20px}.stat-item{display:flex;flex-direction:column;align-items:center;gap:4px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: SkeletonComponent, selector: "val-skeleton", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProfileSkeletonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-skeleton-profile', standalone: true, imports: [CommonModule, SkeletonComponent], template: `
+    <div
+      class="skeleton-profile"
+      [class]="'variant-' + (config.variant || 'default') + ' ' + (config.cssClass || '')"
+    >
+      <div class="profile-header">
+        <!-- Avatar -->
+        <val-skeleton
+          [props]="{
+            type: 'avatar',
+            width: avatarSize,
+            height: avatarSize,
+            animated: config.animated !== false
+          }"
+        ></val-skeleton>
+
+        <div class="profile-info">
+          <!-- Name -->
+          <val-skeleton
+            [props]="{
+              type: 'text',
+              width: nameWidth,
+              height: '20px',
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+          <!-- Subtitle -->
+          <val-skeleton
+            [props]="{
+              type: 'text',
+              width: subtitleWidth,
+              height: '14px',
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+          @if (config.variant === 'full') {
+            <!-- Extra info -->
+            <val-skeleton
+              [props]="{
+                type: 'text',
+                width: '100px',
+                height: '12px',
+                animated: config.animated !== false
+              }"
+            ></val-skeleton>
+          }
+        </div>
+      </div>
+
+      @if (config.variant === 'full') {
+        <div class="profile-details">
+          <val-skeleton
+            [props]="{
+              type: 'paragraph',
+              lines: 3,
+              animated: config.animated !== false
+            }"
+          ></val-skeleton>
+
+          <div class="profile-stats">
+            @for (stat of stats; track $index) {
+              <div class="stat-item">
+                <val-skeleton
+                  [props]="{
+                    type: 'text',
+                    width: '40px',
+                    height: '24px',
+                    animated: config.animated !== false
+                  }"
+                ></val-skeleton>
+                <val-skeleton
+                  [props]="{
+                    type: 'text',
+                    width: '60px',
+                    height: '12px',
+                    animated: config.animated !== false
+                  }"
+                ></val-skeleton>
+              </div>
+            }
+          </div>
+        </div>
+      }
+    </div>
+  `, styles: [".skeleton-profile{width:100%;&.variant-default .profile-header{display:flex;align-items:center;gap:12px}&.variant-full{.profile-header{display:flex;flex-direction:column;align-items:center;gap:16px;text-align:center}.profile-info{align-items:center}.profile-details{margin-top:24px}}}.profile-info{display:flex;flex-direction:column;gap:6px}.profile-stats{display:flex;justify-content:center;gap:32px;margin-top:20px}.stat-item{display:flex;flex-direction:column;align-items:center;gap:4px}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/skeleton/templates/table-skeleton.component.mjs

@@ -0,0 +1,116 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SkeletonComponent } from '../../../components/atoms/skeleton/skeleton.component';
+import * as i0 from "@angular/core";
+/**
+ * Template de skeleton para tablas.
+ *
+ * @example
+ * <val-skeleton-table [config]="{ columns: 5, rows: 10 }"></val-skeleton-table>
+ */
+export class TableSkeletonComponent {
+    constructor() {
+        this.config = { columns: 4, rows: 5 };
+    }
+    get columns() {
+        return Array(this.config.columns ?? 4).fill(0);
+    }
+    get rows() {
+        return Array(this.config.rows ?? 5).fill(0);
+    }
+    getColumnFlex(index) {
+        // Primera columna mas ancha, ultima mas angosta
+        const totalCols = this.config.columns ?? 4;
+        if (index === 0)
+            return '1.5';
+        if (index === totalCols - 1)
+            return '0.8';
+        return '1';
+    }
+    getColumnContentWidth(index) {
+        // Variar anchos para aspecto natural
+        const widths = ['90%', '70%', '60%', '80%', '50%'];
+        return widths[index % widths.length];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableSkeletonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TableSkeletonComponent, isStandalone: true, selector: "val-skeleton-table", inputs: { config: "config" }, ngImport: i0, template: `
+    <div class="skeleton-table" [class]="config.cssClass">
+      <!-- Header -->
+      <div class="skeleton-table-header">
+        @for (col of columns; track $index) {
+          <div class="skeleton-table-cell" [style.flex]="getColumnFlex($index)">
+            <val-skeleton
+              [props]="{
+                type: 'text',
+                width: '80%',
+                height: '16px',
+                animated: config.animated !== false
+              }"
+            ></val-skeleton>
+          </div>
+        }
+      </div>
+
+      <!-- Rows -->
+      @for (row of rows; track $index) {
+        <div class="skeleton-table-row">
+          @for (col of columns; track $index) {
+            <div class="skeleton-table-cell" [style.flex]="getColumnFlex($index)">
+              <val-skeleton
+                [props]="{
+                  type: 'text',
+                  width: getColumnContentWidth($index),
+                  height: '14px',
+                  animated: config.animated !== false
+                }"
+              ></val-skeleton>
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".skeleton-table{width:100%;overflow:hidden;border-radius:8px;border:1px solid var(--ion-color-light-shade, #d7d8da)}.skeleton-table-header{display:flex;align-items:center;gap:16px;padding:14px 16px;background:var(--ion-color-light, #f4f5f8);border-bottom:1px solid var(--ion-color-light-shade, #d7d8da)}.skeleton-table-row{display:flex;align-items:center;gap:16px;padding:12px 16px;border-bottom:1px solid var(--ion-color-light-shade, #d7d8da);&:last-child{border-bottom:none}}.skeleton-table-cell{min-width:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: SkeletonComponent, selector: "val-skeleton", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableSkeletonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-skeleton-table', standalone: true, imports: [CommonModule, SkeletonComponent], template: `
+    <div class="skeleton-table" [class]="config.cssClass">
+      <!-- Header -->
+      <div class="skeleton-table-header">
+        @for (col of columns; track $index) {
+          <div class="skeleton-table-cell" [style.flex]="getColumnFlex($index)">
+            <val-skeleton
+              [props]="{
+                type: 'text',
+                width: '80%',
+                height: '16px',
+                animated: config.animated !== false
+              }"
+            ></val-skeleton>
+          </div>
+        }
+      </div>
+
+      <!-- Rows -->
+      @for (row of rows; track $index) {
+        <div class="skeleton-table-row">
+          @for (col of columns; track $index) {
+            <div class="skeleton-table-cell" [style.flex]="getColumnFlex($index)">
+              <val-skeleton
+                [props]="{
+                  type: 'text',
+                  width: getColumnContentWidth($index),
+                  height: '14px',
+                  animated: config.animated !== false
+                }"
+              ></val-skeleton>
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `, styles: [".skeleton-table{width:100%;overflow:hidden;border-radius:8px;border:1px solid var(--ion-color-light-shade, #d7d8da)}.skeleton-table-header{display:flex;align-items:center;gap:16px;padding:14px 16px;background:var(--ion-color-light, #f4f5f8);border-bottom:1px solid var(--ion-color-light-shade, #d7d8da)}.skeleton-table-row{display:flex;align-items:center;gap:16px;padding:12px 16px;border-bottom:1px solid var(--ion-color-light-shade, #d7d8da);&:last-child{border-bottom:none}}.skeleton-table-cell{min-width:0}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/skeleton/types.mjs

@@ -0,0 +1,11 @@
+/**
+ * Configuracion por defecto para el sistema de skeletons.
+ */
+export const DEFAULT_SKELETON_CONFIG = {
+    animated: true,
+    defaultDelay: 0,
+    defaultMinTime: 300,
+    defaultListTemplate: 'list',
+    defaultGridTemplate: 'grid-cards',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/theme.service.mjs

@@ -0,0 +1,153 @@
+/**
+ * Service for managing application themes (light, dark, auto).
+ * Handles user preferences, system theme detection, and theme toggling.
+ * Uses localStorage to persist the selected theme.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { THEME } from '../shared/constants/storage';
+import { LocalStorageService } from './local-storage.service';
+import * as i0 from "@angular/core";
+export var ThemeOption;
+(function (ThemeOption) {
+    ThemeOption["LIGHT"] = "light";
+    ThemeOption["DARK"] = "dark";
+    ThemeOption["AUTO"] = "auto";
+})(ThemeOption || (ThemeOption = {}));
+export class ThemeService {
+    constructor() {
+        /**
+         * Indicates if the light theme is active.
+         */
+        this.lightToggle = false;
+        /**
+         * Indicates if the dark theme is active.
+         */
+        this.darkToggle = false;
+        /**
+         * Indicates if the auto theme is active.
+         */
+        this.autoToggle = false;
+        /**
+         * The current selected theme option.
+         */
+        this.currentOption = ThemeOption.AUTO;
+        /**
+         * Enum with all available theme options.
+         */
+        this.themeOptions = ThemeOption;
+        /**
+         * Whether the system prefers dark mode.
+         */
+        this.prefersDark = false;
+        /**
+         * The default theme option.
+         */
+        this.default = ThemeOption.AUTO;
+        const current = LocalStorageService.get(THEME);
+        console.log('💡 ThemeConfig current::: ', current);
+        this.theme = new BehaviorSubject(current || this.default);
+        this.currentOption = this.Theme;
+        console.log('💡 ThemeConfig this.currentOption::: ', this.currentOption);
+        this.toggleUserPreference(this.currentOption);
+        const prefersDarkQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        this.prefersDark = prefersDarkQuery.matches;
+        this.handleAutoConfiguration();
+        prefersDarkQuery.addEventListener('change', mediaQuery => {
+            console.log('💡 ThemeConfig addEventListener change::: ', mediaQuery);
+            this.prefersDark = mediaQuery.matches;
+            this.handleAutoConfiguration();
+        });
+    }
+    handleAutoConfiguration() {
+        if (this.prefersDark && this.currentOption === ThemeOption.AUTO) {
+            console.log('💡 ThemeConfig prefersDark::: ', this.prefersDark);
+            this.toggleUserPreference(ThemeOption.AUTO);
+        }
+        if (!this.prefersDark && this.currentOption === ThemeOption.AUTO) {
+            console.log('💡 ThemeConfig prefersDark::: ', this.prefersDark);
+            this.toggleUserPreference(ThemeOption.AUTO);
+        }
+    }
+    handleDarkPreference() {
+        this.toggleTheme(ThemeOption.DARK, true);
+        this.toggleTheme(ThemeOption.LIGHT, false);
+    }
+    handleLightPreference() {
+        this.toggleTheme(ThemeOption.LIGHT, true);
+        this.toggleTheme(ThemeOption.DARK, false);
+    }
+    /**
+     * Returns true if the system prefers dark mode.
+     */
+    get IsDark() {
+        return this.prefersDark;
+    }
+    /**
+     * Gets the current theme option.
+     */
+    get Theme() {
+        return this.theme.value;
+    }
+    /**
+     * Sets the current theme option and persists it.
+     */
+    set Theme(theme) {
+        this.theme.next(theme);
+        LocalStorageService.set(THEME, theme);
+    }
+    /**
+     * Toggles a theme class on the document body.
+     * @param name The theme name
+     * @param shouldAdd Whether to add or remove the class
+     *
+     * Ionic 8 (`dark.class.css` palette) usa `.ion-palette-dark` en `<html>` para
+     * conmutar el tema dark; en versiones previas leía `body.dark`. Mantenemos
+     * el toggle sobre `body.{name}` por compat con código legacy, y además
+     * espejamos `ion-palette-dark` en `<html>` cuando `name === 'dark'` — esto
+     * es lo que las apps en Ionic 8 necesitan para que el palette aplique.
+     */
+    toggleTheme(name, shouldAdd) {
+        console.log('toggleTheme::: ', name, shouldAdd);
+        document.body.classList.toggle(name, shouldAdd);
+        if (name === 'dark') {
+            document.documentElement.classList.toggle('ion-palette-dark', shouldAdd);
+        }
+    }
+    /**
+     * Sets the user theme preference and updates toggles and theme classes.
+     * @param option The selected theme option
+     */
+    toggleUserPreference(option) {
+        this.currentOption = option;
+        this.Theme = option;
+        this.lightToggle = option === ThemeOption.LIGHT;
+        this.darkToggle = option === ThemeOption.DARK;
+        this.autoToggle = option === ThemeOption.AUTO;
+        switch (option) {
+            case ThemeOption.LIGHT:
+                this.handleLightPreference();
+                break;
+            case ThemeOption.DARK:
+                this.handleDarkPreference();
+                break;
+            case ThemeOption.AUTO:
+                if (this.prefersDark) {
+                    this.handleDarkPreference();
+                }
+                else {
+                    this.handleLightPreference();
+                }
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Service for managing application themes (light, dark, auto).\n * Handles user preferences, system theme detection, and theme toggling.\n * Uses localStorage to persist the selected theme.\n */\n\nimport { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { THEME } from '../shared/constants/storage';\nimport { LocalStorageService } from './local-storage.service';\n\nexport enum ThemeOption {\n  LIGHT = 'light',\n  DARK = 'dark',\n  AUTO = 'auto',\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ThemeService {\n  /**\n   * Indicates if the light theme is active.\n   */\n  lightToggle = false;\n  /**\n   * Indicates if the dark theme is active.\n   */\n  darkToggle = false;\n  /**\n   * Indicates if the auto theme is active.\n   */\n  autoToggle = false;\n  /**\n   * The current selected theme option.\n   */\n  currentOption = ThemeOption.AUTO;\n  /**\n   * Enum with all available theme options.\n   */\n  themeOptions = ThemeOption;\n  /**\n   * Whether the system prefers dark mode.\n   */\n  prefersDark = false;\n  /**\n   * The default theme option.\n   */\n  default = ThemeOption.AUTO;\n  /**\n   * Observable for the current theme.\n   */\n  theme: BehaviorSubject<ThemeOption>;\n\n  constructor() {\n    const current = LocalStorageService.get<ThemeOption>(THEME);\n    console.log('💡 ThemeConfig current::: ', current);\n    this.theme = new BehaviorSubject<ThemeOption>(current || this.default);\n    this.currentOption = this.Theme;\n    console.log('💡 ThemeConfig this.currentOption::: ', this.currentOption);\n    this.toggleUserPreference(this.currentOption);\n\n    const prefersDarkQuery = window.matchMedia('(prefers-color-scheme: dark)');\n    this.prefersDark = prefersDarkQuery.matches;\n    this.handleAutoConfiguration();\n\n    prefersDarkQuery.addEventListener('change', mediaQuery => {\n      console.log('💡 ThemeConfig addEventListener change::: ', mediaQuery);\n      this.prefersDark = mediaQuery.matches;\n      this.handleAutoConfiguration();\n    });\n  }\n\n  private handleAutoConfiguration() {\n    if (this.prefersDark && this.currentOption === ThemeOption.AUTO) {\n      console.log('💡 ThemeConfig prefersDark::: ', this.prefersDark);\n      this.toggleUserPreference(ThemeOption.AUTO);\n    }\n    if (!this.prefersDark && this.currentOption === ThemeOption.AUTO) {\n      console.log('💡 ThemeConfig prefersDark::: ', this.prefersDark);\n      this.toggleUserPreference(ThemeOption.AUTO);\n    }\n  }\n\n  private handleDarkPreference() {\n    this.toggleTheme(ThemeOption.DARK, true);\n    this.toggleTheme(ThemeOption.LIGHT, false);\n  }\n\n  private handleLightPreference() {\n    this.toggleTheme(ThemeOption.LIGHT, true);\n    this.toggleTheme(ThemeOption.DARK, false);\n  }\n\n  /**\n   * Returns true if the system prefers dark mode.\n   */\n  get IsDark(): boolean {\n    return this.prefersDark;\n  }\n\n  /**\n   * Gets the current theme option.\n   */\n  get Theme(): ThemeOption {\n    return this.theme.value;\n  }\n\n  /**\n   * Sets the current theme option and persists it.\n   */\n  set Theme(theme: ThemeOption) {\n    this.theme.next(theme);\n    LocalStorageService.set<ThemeOption>(THEME, theme);\n  }\n\n  /**\n   * Toggles a theme class on the document body.\n   * @param name The theme name\n   * @param shouldAdd Whether to add or remove the class\n   *\n   * Ionic 8 (`dark.class.css` palette) usa `.ion-palette-dark` en `<html>` para\n   * conmutar el tema dark; en versiones previas leía `body.dark`. Mantenemos\n   * el toggle sobre `body.{name}` por compat con código legacy, y además\n   * espejamos `ion-palette-dark` en `<html>` cuando `name === 'dark'` — esto\n   * es lo que las apps en Ionic 8 necesitan para que el palette aplique.\n   */\n  toggleTheme(name: string, shouldAdd: boolean) {\n    console.log('toggleTheme::: ', name, shouldAdd);\n    document.body.classList.toggle(name, shouldAdd);\n    if (name === 'dark') {\n      document.documentElement.classList.toggle('ion-palette-dark', shouldAdd);\n    }\n  }\n\n  /**\n   * Sets the user theme preference and updates toggles and theme classes.\n   * @param option The selected theme option\n   */\n  toggleUserPreference(option: ThemeOption) {\n    this.currentOption = option;\n    this.Theme = option;\n    this.lightToggle = option === ThemeOption.LIGHT;\n    this.darkToggle = option === ThemeOption.DARK;\n    this.autoToggle = option === ThemeOption.AUTO;\n\n    switch (option) {\n      case ThemeOption.LIGHT:\n        this.handleLightPreference();\n        break;\n      case ThemeOption.DARK:\n        this.handleDarkPreference();\n        break;\n      case ThemeOption.AUTO:\n        if (this.prefersDark) {\n          this.handleDarkPreference();\n        } else {\n          this.handleLightPreference();\n        }\n        break;\n    }\n  }\n}\n"]}

package/esm2022/lib/services/toast.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+/**
+ * Service for displaying toast notifications using Ionic's ToastController.
+ * Provides methods to show and present toasts with custom options.
+ */
+export class ToastService {
+    constructor(toastController) {
+        this.toastController = toastController;
+    }
+    /**
+     * Presents a toast notification with the given options.
+     *
+     * Estándar Valtech: todos los toasts son `color: 'dark'` y `position: 'top'`.
+     * Estos son los defaults cuando el caller no los especifica — no hace falta
+     * pasarlos en cada llamada. El diferenciador semántico (éxito/error) va en
+     * el mensaje, no en el color.
+     *
+     * @param request Toast options (message, duration, position, color, etc.)
+     */
+    async presentToast(request) {
+        const toast = await this.toastController.create({
+            message: request.message,
+            duration: request.duration,
+            position: request.position ?? 'top',
+            color: request.color ?? 'dark',
+        });
+        await toast.present();
+    }
+    /**
+     * Shows a toast notification and logs the result.
+     * @param request Toast options (message, duration, position, color, etc.)
+     */
+    show(request) {
+        this.presentToast(request)
+            .then(() => {
+            console.info('Toast created');
+        })
+            .catch(error => {
+            console.error(JSON.stringify(error));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToastService, deps: [{ token: i1.ToastController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToastService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ToastController }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/types.mjs

@@ -0,0 +1,5 @@
+// Types for valtech-components services
+// ValtechConfig and LangProvider have been removed in v3.0.0
+// Use LocaleService for language management instead
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdDQUF3QztBQUN4Qyw2REFBNkQ7QUFDN0Qsb0RBQW9EIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXMgZm9yIHZhbHRlY2gtY29tcG9uZW50cyBzZXJ2aWNlc1xuLy8gVmFsdGVjaENvbmZpZyBhbmQgTGFuZ1Byb3ZpZGVyIGhhdmUgYmVlbiByZW1vdmVkIGluIHYzLjAuMFxuLy8gVXNlIExvY2FsZVNlcnZpY2UgZm9yIGxhbmd1YWdlIG1hbmFnZW1lbnQgaW5zdGVhZFxuXG4vLyBFbXB0eSBleHBvcnQgdG8gbWFpbnRhaW4gbW9kdWxlIGNvbXBhdGliaWxpdHlcbmV4cG9ydCB7fTtcbiJdfQ==

package/esm2022/lib/shared/constants/storage.mjs

@@ -0,0 +1,3 @@
+export const LANG = 'LANG';
+export const THEME = 'THEME';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2hhcmVkL2NvbnN0YW50cy9zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxNQUFNLENBQUM7QUFDM0IsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBMQU5HID0gJ0xBTkcnO1xuZXhwb3J0IGNvbnN0IFRIRU1FID0gJ1RIRU1FJztcbiJdfQ==