valtech-components 2.0.404 → 2.0.406

package/esm2022/lib/services/qr-generator/qr-generator.service.mjs

@@ -0,0 +1,341 @@
+import { Injectable } from '@angular/core';
+import QRCodeStyling from 'qr-code-styling';
+import { QR_PRESETS, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * QrGeneratorService
+ *
+ * A comprehensive service for generating, customizing, and manipulating QR codes.
+ * Uses qr-code-styling library for high-quality, customizable QR code generation.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const qr = await this.qrService.generate({ data: 'https://example.com' });
+ * console.log(qr.dataUrl); // base64 image
+ * ```
+ *
+ * @example With customization
+ * ```typescript
+ * const qr = await this.qrService.generate({
+ *   data: 'https://example.com',
+ *   width: 400,
+ *   dotsStyle: 'rounded',
+ *   dotsColor: '#3880ff',
+ *   logo: { src: 'logo.png', width: 60 }
+ * });
+ * ```
+ *
+ * @example Using presets
+ * ```typescript
+ * const qr = await this.qrService.generateFromPreset('modern', 'https://example.com');
+ * ```
+ */
+export class QrGeneratorService {
+    /**
+     * Generate a QR code with the given configuration.
+     *
+     * @param config - QR code configuration
+     * @returns Promise<QrResult> - Generated QR code result
+     *
+     * @example
+     * ```typescript
+     * const qr = await this.qrService.generate({
+     *   data: 'https://myapp.com/product/123',
+     *   width: 300,
+     *   dotsStyle: 'rounded',
+     *   dotsColor: '#000000',
+     *   backgroundColor: '#ffffff'
+     * });
+     * ```
+     */
+    async generate(config) {
+        // Merge with defaults
+        const finalConfig = {
+            width: 300,
+            height: config.height || config.width || 300,
+            margin: 0,
+            dotsStyle: 'square',
+            dotsColor: '#000000',
+            backgroundColor: '#ffffff',
+            errorCorrectionLevel: 'M',
+            format: 'png',
+            quality: 1,
+            ...config,
+        };
+        // Build qr-code-styling options
+        const qrOptions = {
+            width: finalConfig.width,
+            height: finalConfig.height,
+            data: finalConfig.data,
+            margin: finalConfig.margin,
+            qrOptions: {
+                errorCorrectionLevel: finalConfig.errorCorrectionLevel,
+            },
+            dotsOptions: {
+                type: finalConfig.dotsStyle,
+                ...this.buildColorOptions(finalConfig.dotsColor),
+            },
+            backgroundOptions: {
+                ...this.buildColorOptions(finalConfig.backgroundColor),
+            },
+            cornersSquareOptions: finalConfig.cornersSquareColor || finalConfig.cornersSquareStyle
+                ? {
+                    type: finalConfig.cornersSquareStyle,
+                    ...this.buildColorOptions(finalConfig.cornersSquareColor || finalConfig.dotsColor),
+                }
+                : undefined,
+            cornersDotOptions: finalConfig.cornersDotColor || finalConfig.cornersDotStyle
+                ? {
+                    type: finalConfig.cornersDotStyle,
+                    ...this.buildColorOptions(finalConfig.cornersDotColor || finalConfig.dotsColor),
+                }
+                : undefined,
+        };
+        // Add logo if provided
+        if (finalConfig.logo) {
+            qrOptions.image = finalConfig.logo.src;
+            qrOptions.imageOptions = {
+                hideBackgroundDots: finalConfig.logo.hideBackgroundDots ?? true,
+                imageSize: 0.4,
+                margin: finalConfig.logo.margin ?? 5,
+                crossOrigin: 'anonymous',
+            };
+        }
+        // Create QR code instance
+        const qrCode = new QRCodeStyling(qrOptions);
+        // Generate blob
+        const format = finalConfig.format || 'png';
+        const mimeType = this.getMimeType(format);
+        const extension = format === 'jpeg' ? 'jpg' : format;
+        let blob;
+        let svg;
+        let dataUrl;
+        if (format === 'svg') {
+            // Get SVG data
+            const svgData = await qrCode.getRawData('svg');
+            if (!svgData) {
+                throw new Error('Failed to generate SVG');
+            }
+            blob = svgData;
+            svg = await blob.text();
+            dataUrl = `data:${mimeType};base64,${btoa(svg)}`;
+        }
+        else {
+            // Get image blob
+            const imageBlob = await qrCode.getRawData(format);
+            if (!imageBlob) {
+                throw new Error('Failed to generate image');
+            }
+            blob = imageBlob;
+            dataUrl = await this.blobToDataUrl(blob);
+        }
+        return {
+            config: finalConfig,
+            dataUrl,
+            blob,
+            svg,
+            mimeType,
+            extension,
+            generatedAt: new Date(),
+        };
+    }
+    /**
+     * Generate a QR code using a preset configuration.
+     *
+     * @param preset - Preset name ('default', 'rounded', 'dots', 'classy', 'modern')
+     * @param data - Data to encode
+     * @param overrides - Optional configuration overrides
+     * @returns Promise<QrResult>
+     */
+    async generateFromPreset(preset, data, overrides) {
+        const presetConfig = QR_PRESETS[preset] || QR_PRESETS['default'];
+        return this.generate({
+            ...presetConfig,
+            ...overrides,
+            data,
+        });
+    }
+    /**
+     * Download the QR code as a file.
+     *
+     * @param qr - QR result to download
+     * @param options - Download options
+     */
+    async download(qr, options) {
+        const filename = options?.filename || `qr-code-${Date.now()}`;
+        const format = options?.format || qr.config.format || 'png';
+        const extension = format === 'jpeg' ? 'jpg' : format;
+        let blob = qr.blob;
+        // Convert if different format requested
+        if (options?.format && options.format !== qr.config.format) {
+            const newQr = await this.generate({
+                ...qr.config,
+                format: options.format,
+            });
+            blob = newQr.blob;
+        }
+        // Create download link
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `${filename}.${extension}`;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Copy the QR code to clipboard as an image.
+     *
+     * @param qr - QR result to copy
+     * @returns Promise<boolean> - Whether copy was successful
+     */
+    async copyToClipboard(qr) {
+        try {
+            // Clipboard API requires PNG format
+            let pngBlob = qr.blob;
+            if (qr.mimeType !== 'image/png') {
+                const pngQr = await this.generate({
+                    ...qr.config,
+                    format: 'png',
+                });
+                pngBlob = pngQr.blob;
+            }
+            await navigator.clipboard.write([
+                new ClipboardItem({
+                    'image/png': pngBlob,
+                }),
+            ]);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to copy QR to clipboard:', error);
+            return false;
+        }
+    }
+    /**
+     * Share the QR code using Web Share API.
+     *
+     * @param qr - QR result to share
+     * @param options - Share options
+     * @returns Promise<boolean> - Whether share was successful
+     */
+    async share(qr, options) {
+        if (!navigator.share || !navigator.canShare) {
+            console.warn('Web Share API not available');
+            return false;
+        }
+        try {
+            const filename = options?.filename || `qr-code-${Date.now()}.${qr.extension}`;
+            const file = new File([qr.blob], filename, { type: qr.mimeType });
+            const shareData = {
+                title: options?.title || 'QR Code',
+                text: options?.text,
+                files: [file],
+            };
+            if (navigator.canShare(shareData)) {
+                await navigator.share(shareData);
+                return true;
+            }
+            // Fallback without file
+            await navigator.share({
+                title: options?.title || 'QR Code',
+                text: options?.text,
+            });
+            return true;
+        }
+        catch (error) {
+            if (error.name !== 'AbortError') {
+                console.error('Failed to share QR:', error);
+            }
+            return false;
+        }
+    }
+    /**
+     * Get the QR code as a base64 string (without data URL prefix).
+     *
+     * @param qr - QR result
+     * @returns Base64 string
+     */
+    toBase64(qr) {
+        const prefix = `data:${qr.mimeType};base64,`;
+        if (qr.dataUrl.startsWith(prefix)) {
+            return qr.dataUrl.substring(prefix.length);
+        }
+        return qr.dataUrl;
+    }
+    /**
+     * Get the QR code as a data URL.
+     *
+     * @param qr - QR result
+     * @returns Data URL string
+     */
+    toDataUrl(qr) {
+        return qr.dataUrl;
+    }
+    /**
+     * Get the QR code as a Blob.
+     *
+     * @param qr - QR result
+     * @returns Blob
+     */
+    toBlob(qr) {
+        return qr.blob;
+    }
+    /**
+     * Check if Web Share API is available.
+     */
+    canShare() {
+        return !!(navigator.share && navigator.canShare);
+    }
+    /**
+     * Check if Clipboard API is available for images.
+     */
+    canCopyToClipboard() {
+        return !!(navigator.clipboard && navigator.clipboard.write);
+    }
+    // === Private Helpers ===
+    buildColorOptions(color) {
+        if (!color) {
+            return {};
+        }
+        if (typeof color === 'string') {
+            return { color };
+        }
+        // Gradient
+        const gradient = color;
+        return {
+            gradient: {
+                type: gradient.type,
+                rotation: gradient.rotation || 0,
+                colorStops: gradient.colorStops,
+            },
+        };
+    }
+    getMimeType(format) {
+        const mimeTypes = {
+            png: 'image/png',
+            jpeg: 'image/jpeg',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+        };
+        return mimeTypes[format] || 'image/png';
+    }
+    blobToDataUrl(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qr-generator.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr-generator/qr-generator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport QRCodeStyling from 'qr-code-styling';\nimport {\n  QrConfig,\n  QrResult,\n  QrDownloadOptions,\n  QrShareOptions,\n  QrColorConfig,\n  QrGradient,\n  QR_PRESETS,\n} from './types';\n\n/**\n * QrGeneratorService\n *\n * A comprehensive service for generating, customizing, and manipulating QR codes.\n * Uses qr-code-styling library for high-quality, customizable QR code generation.\n *\n * @example Basic usage\n * ```typescript\n * const qr = await this.qrService.generate({ data: 'https://example.com' });\n * console.log(qr.dataUrl); // base64 image\n * ```\n *\n * @example With customization\n * ```typescript\n * const qr = await this.qrService.generate({\n *   data: 'https://example.com',\n *   width: 400,\n *   dotsStyle: 'rounded',\n *   dotsColor: '#3880ff',\n *   logo: { src: 'logo.png', width: 60 }\n * });\n * ```\n *\n * @example Using presets\n * ```typescript\n * const qr = await this.qrService.generateFromPreset('modern', 'https://example.com');\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class QrGeneratorService {\n  /**\n   * Generate a QR code with the given configuration.\n   *\n   * @param config - QR code configuration\n   * @returns Promise<QrResult> - Generated QR code result\n   *\n   * @example\n   * ```typescript\n   * const qr = await this.qrService.generate({\n   *   data: 'https://myapp.com/product/123',\n   *   width: 300,\n   *   dotsStyle: 'rounded',\n   *   dotsColor: '#000000',\n   *   backgroundColor: '#ffffff'\n   * });\n   * ```\n   */\n  async generate(config: QrConfig): Promise<QrResult> {\n\n    // Merge with defaults\n    const finalConfig: QrConfig = {\n      width: 300,\n      height: config.height || config.width || 300,\n      margin: 0,\n      dotsStyle: 'square',\n      dotsColor: '#000000',\n      backgroundColor: '#ffffff',\n      errorCorrectionLevel: 'M',\n      format: 'png',\n      quality: 1,\n      ...config,\n    };\n\n    // Build qr-code-styling options\n    const qrOptions: any = {\n      width: finalConfig.width,\n      height: finalConfig.height,\n      data: finalConfig.data,\n      margin: finalConfig.margin,\n      qrOptions: {\n        errorCorrectionLevel: finalConfig.errorCorrectionLevel,\n      },\n      dotsOptions: {\n        type: finalConfig.dotsStyle,\n        ...this.buildColorOptions(finalConfig.dotsColor),\n      },\n      backgroundOptions: {\n        ...this.buildColorOptions(finalConfig.backgroundColor),\n      },\n      cornersSquareOptions: finalConfig.cornersSquareColor || finalConfig.cornersSquareStyle\n        ? {\n            type: finalConfig.cornersSquareStyle,\n            ...this.buildColorOptions(finalConfig.cornersSquareColor || finalConfig.dotsColor),\n          }\n        : undefined,\n      cornersDotOptions: finalConfig.cornersDotColor || finalConfig.cornersDotStyle\n        ? {\n            type: finalConfig.cornersDotStyle,\n            ...this.buildColorOptions(finalConfig.cornersDotColor || finalConfig.dotsColor),\n          }\n        : undefined,\n    };\n\n    // Add logo if provided\n    if (finalConfig.logo) {\n      qrOptions.image = finalConfig.logo.src;\n      qrOptions.imageOptions = {\n        hideBackgroundDots: finalConfig.logo.hideBackgroundDots ?? true,\n        imageSize: 0.4,\n        margin: finalConfig.logo.margin ?? 5,\n        crossOrigin: 'anonymous',\n      };\n    }\n\n    // Create QR code instance\n    const qrCode = new QRCodeStyling(qrOptions);\n\n    // Generate blob\n    const format = finalConfig.format || 'png';\n    const mimeType = this.getMimeType(format);\n    const extension = format === 'jpeg' ? 'jpg' : format;\n\n    let blob: Blob;\n    let svg: string | undefined;\n    let dataUrl: string;\n\n    if (format === 'svg') {\n      // Get SVG data\n      const svgData = await qrCode.getRawData('svg');\n      if (!svgData) {\n        throw new Error('Failed to generate SVG');\n      }\n      blob = svgData as Blob;\n      svg = await blob.text();\n      dataUrl = `data:${mimeType};base64,${btoa(svg)}`;\n    } else {\n      // Get image blob\n      const imageBlob = await qrCode.getRawData(format as 'png' | 'jpeg' | 'webp');\n      if (!imageBlob) {\n        throw new Error('Failed to generate image');\n      }\n      blob = imageBlob as Blob;\n      dataUrl = await this.blobToDataUrl(blob);\n    }\n\n    return {\n      config: finalConfig,\n      dataUrl,\n      blob,\n      svg,\n      mimeType,\n      extension,\n      generatedAt: new Date(),\n    };\n  }\n\n  /**\n   * Generate a QR code using a preset configuration.\n   *\n   * @param preset - Preset name ('default', 'rounded', 'dots', 'classy', 'modern')\n   * @param data - Data to encode\n   * @param overrides - Optional configuration overrides\n   * @returns Promise<QrResult>\n   */\n  async generateFromPreset(\n    preset: keyof typeof QR_PRESETS | string,\n    data: string,\n    overrides?: Partial<QrConfig>\n  ): Promise<QrResult> {\n    const presetConfig = QR_PRESETS[preset] || QR_PRESETS['default'];\n    return this.generate({\n      ...presetConfig,\n      ...overrides,\n      data,\n    });\n  }\n\n  /**\n   * Download the QR code as a file.\n   *\n   * @param qr - QR result to download\n   * @param options - Download options\n   */\n  async download(qr: QrResult, options?: QrDownloadOptions): Promise<void> {\n    const filename = options?.filename || `qr-code-${Date.now()}`;\n    const format = options?.format || qr.config.format || 'png';\n    const extension = format === 'jpeg' ? 'jpg' : format;\n\n    let blob = qr.blob;\n\n    // Convert if different format requested\n    if (options?.format && options.format !== qr.config.format) {\n      const newQr = await this.generate({\n        ...qr.config,\n        format: options.format,\n      });\n      blob = newQr.blob;\n    }\n\n    // Create download link\n    const url = URL.createObjectURL(blob);\n    const link = document.createElement('a');\n    link.href = url;\n    link.download = `${filename}.${extension}`;\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n  }\n\n  /**\n   * Copy the QR code to clipboard as an image.\n   *\n   * @param qr - QR result to copy\n   * @returns Promise<boolean> - Whether copy was successful\n   */\n  async copyToClipboard(qr: QrResult): Promise<boolean> {\n    try {\n      // Clipboard API requires PNG format\n      let pngBlob = qr.blob;\n\n      if (qr.mimeType !== 'image/png') {\n        const pngQr = await this.generate({\n          ...qr.config,\n          format: 'png',\n        });\n        pngBlob = pngQr.blob;\n      }\n\n      await navigator.clipboard.write([\n        new ClipboardItem({\n          'image/png': pngBlob,\n        }),\n      ]);\n\n      return true;\n    } catch (error) {\n      console.error('Failed to copy QR to clipboard:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Share the QR code using Web Share API.\n   *\n   * @param qr - QR result to share\n   * @param options - Share options\n   * @returns Promise<boolean> - Whether share was successful\n   */\n  async share(qr: QrResult, options?: QrShareOptions): Promise<boolean> {\n    if (!navigator.share || !navigator.canShare) {\n      console.warn('Web Share API not available');\n      return false;\n    }\n\n    try {\n      const filename = options?.filename || `qr-code-${Date.now()}.${qr.extension}`;\n      const file = new File([qr.blob], filename, { type: qr.mimeType });\n\n      const shareData: ShareData = {\n        title: options?.title || 'QR Code',\n        text: options?.text,\n        files: [file],\n      };\n\n      if (navigator.canShare(shareData)) {\n        await navigator.share(shareData);\n        return true;\n      }\n\n      // Fallback without file\n      await navigator.share({\n        title: options?.title || 'QR Code',\n        text: options?.text,\n      });\n\n      return true;\n    } catch (error) {\n      if ((error as Error).name !== 'AbortError') {\n        console.error('Failed to share QR:', error);\n      }\n      return false;\n    }\n  }\n\n  /**\n   * Get the QR code as a base64 string (without data URL prefix).\n   *\n   * @param qr - QR result\n   * @returns Base64 string\n   */\n  toBase64(qr: QrResult): string {\n    const prefix = `data:${qr.mimeType};base64,`;\n    if (qr.dataUrl.startsWith(prefix)) {\n      return qr.dataUrl.substring(prefix.length);\n    }\n    return qr.dataUrl;\n  }\n\n  /**\n   * Get the QR code as a data URL.\n   *\n   * @param qr - QR result\n   * @returns Data URL string\n   */\n  toDataUrl(qr: QrResult): string {\n    return qr.dataUrl;\n  }\n\n  /**\n   * Get the QR code as a Blob.\n   *\n   * @param qr - QR result\n   * @returns Blob\n   */\n  toBlob(qr: QrResult): Blob {\n    return qr.blob;\n  }\n\n  /**\n   * Check if Web Share API is available.\n   */\n  canShare(): boolean {\n    return !!(navigator.share && navigator.canShare);\n  }\n\n  /**\n   * Check if Clipboard API is available for images.\n   */\n  canCopyToClipboard(): boolean {\n    return !!(navigator.clipboard && navigator.clipboard.write);\n  }\n\n  // === Private Helpers ===\n\n  private buildColorOptions(color?: QrColorConfig): any {\n    if (!color) {\n      return {};\n    }\n\n    if (typeof color === 'string') {\n      return { color };\n    }\n\n    // Gradient\n    const gradient = color as QrGradient;\n    return {\n      gradient: {\n        type: gradient.type,\n        rotation: gradient.rotation || 0,\n        colorStops: gradient.colorStops,\n      },\n    };\n  }\n\n  private getMimeType(format: string): string {\n    const mimeTypes: Record<string, string> = {\n      png: 'image/png',\n      jpeg: 'image/jpeg',\n      webp: 'image/webp',\n      svg: 'image/svg+xml',\n    };\n    return mimeTypes[format] || 'image/png';\n  }\n\n  private blobToDataUrl(blob: Blob): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const reader = new FileReader();\n      reader.onloadend = () => resolve(reader.result as string);\n      reader.onerror = reject;\n      reader.readAsDataURL(blob);\n    });\n  }\n}\n"]}

package/esm2022/lib/services/qr-generator/types.mjs

@@ -0,0 +1,46 @@
+/**
+ * Default presets for quick styling.
+ */
+export const QR_PRESETS = {
+    default: {
+        width: 300,
+        dotsStyle: 'square',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+        errorCorrectionLevel: 'M',
+    },
+    rounded: {
+        width: 300,
+        dotsStyle: 'rounded',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    dots: {
+        width: 300,
+        dotsStyle: 'dots',
+        cornersSquareStyle: 'dot',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    classy: {
+        width: 300,
+        dotsStyle: 'classy',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    modern: {
+        width: 300,
+        dotsStyle: 'extra-rounded',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#1a1a1a',
+        backgroundColor: '#ffffff',
+        margin: 2,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr-generator/types.ts"],"names":[],"mappings":"AAkKA;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAsC;IAC3D,OAAO,EAAE;QACP,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,QAAQ;QACnB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,oBAAoB,EAAE,GAAG;KAC1B;IACD,OAAO,EAAE;QACP,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,SAAS;QACpB,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,IAAI,EAAE;QACJ,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,MAAM;QACjB,kBAAkB,EAAE,KAAK;QACzB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,MAAM,EAAE;QACN,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,QAAQ;QACnB,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,MAAM,EAAE;QACN,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,MAAM,EAAE,CAAC;KACV;CACF,CAAC","sourcesContent":["/**\n * Style options for QR code dots (data modules).\n */\nexport type QrDotsStyle = 'square' | 'dots' | 'rounded' | 'extra-rounded' | 'classy' | 'classy-rounded';\n\n/**\n * Style options for QR code corner squares.\n */\nexport type QrCornersSquareStyle = 'square' | 'dot' | 'extra-rounded';\n\n/**\n * Style options for QR code corner dots.\n */\nexport type QrCornersDotStyle = 'square' | 'dot';\n\n/**\n * Output format for the generated QR code.\n */\nexport type QrOutputFormat = 'svg' | 'png' | 'jpeg' | 'webp';\n\n/**\n * Error correction level for QR codes.\n * Higher levels allow more damage tolerance but reduce data capacity.\n */\nexport type QrErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H';\n\n/**\n * Logo/image configuration for the QR code center.\n */\nexport interface QrLogoConfig {\n  /** Image source URL or base64 */\n  src: string;\n  /** Logo width (default: 25% of QR size) */\n  width?: number;\n  /** Logo height (default: same as width) */\n  height?: number;\n  /** Margin around the logo */\n  margin?: number;\n  /** Border radius for rounded corners */\n  borderRadius?: number;\n  /** Whether to hide dots behind the logo */\n  hideBackgroundDots?: boolean;\n}\n\n/**\n * Gradient configuration for QR elements.\n */\nexport interface QrGradient {\n  /** Gradient type */\n  type: 'linear' | 'radial';\n  /** Rotation angle in degrees (for linear) */\n  rotation?: number;\n  /** Color stops */\n  colorStops: Array<{\n    offset: number;\n    color: string;\n  }>;\n}\n\n/**\n * Color configuration - can be solid color or gradient.\n */\nexport type QrColorConfig = string | QrGradient;\n\n/**\n * Complete configuration for QR code generation.\n */\nexport interface QrConfig {\n  /** The data to encode (URL, text, etc.) */\n  data: string;\n\n  // === Size ===\n  /** QR code width in pixels (default: 300) */\n  width?: number;\n  /** QR code height in pixels (default: same as width) */\n  height?: number;\n  /** Quiet zone margin in modules (default: 0) */\n  margin?: number;\n\n  // === Colors ===\n  /** Color/gradient for data dots */\n  dotsColor?: QrColorConfig;\n  /** Background color (default: white) */\n  backgroundColor?: QrColorConfig;\n  /** Color for corner squares */\n  cornersSquareColor?: QrColorConfig;\n  /** Color for corner dots */\n  cornersDotColor?: QrColorConfig;\n\n  // === Styles ===\n  /** Style of data dots (default: 'square') */\n  dotsStyle?: QrDotsStyle;\n  /** Style of corner squares (default: 'square') */\n  cornersSquareStyle?: QrCornersSquareStyle;\n  /** Style of corner dots (default: 'square') */\n  cornersDotStyle?: QrCornersDotStyle;\n\n  // === Logo ===\n  /** Logo/image configuration */\n  logo?: QrLogoConfig;\n\n  // === Technical ===\n  /** Error correction level (default: 'M') */\n  errorCorrectionLevel?: QrErrorCorrectionLevel;\n\n  // === Output ===\n  /** Output format (default: 'png') */\n  format?: QrOutputFormat;\n  /** Quality for jpeg/webp (0-1, default: 1) */\n  quality?: number;\n}\n\n/**\n * Result from QR code generation.\n */\nexport interface QrResult {\n  /** Original configuration used */\n  config: QrConfig;\n  /** Generated data as base64 data URL */\n  dataUrl: string;\n  /** Generated data as Blob */\n  blob: Blob;\n  /** SVG string (only when format is 'svg') */\n  svg?: string;\n  /** MIME type of the generated image */\n  mimeType: string;\n  /** File extension */\n  extension: string;\n  /** Timestamp of generation */\n  generatedAt: Date;\n}\n\n/**\n * Options for downloading the QR code.\n */\nexport interface QrDownloadOptions {\n  /** Custom filename (without extension) */\n  filename?: string;\n  /** Override format for download */\n  format?: QrOutputFormat;\n}\n\n/**\n * Options for sharing the QR code.\n */\nexport interface QrShareOptions {\n  /** Share title */\n  title?: string;\n  /** Share text/description */\n  text?: string;\n  /** Custom filename for the shared file */\n  filename?: string;\n}\n\n/**\n * Preset configurations for common use cases.\n */\nexport interface QrPreset {\n  name: string;\n  config: Partial<QrConfig>;\n}\n\n/**\n * Default presets for quick styling.\n */\nexport const QR_PRESETS: Record<string, Partial<QrConfig>> = {\n  default: {\n    width: 300,\n    dotsStyle: 'square',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n    errorCorrectionLevel: 'M',\n  },\n  rounded: {\n    width: 300,\n    dotsStyle: 'rounded',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  dots: {\n    width: 300,\n    dotsStyle: 'dots',\n    cornersSquareStyle: 'dot',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  classy: {\n    width: 300,\n    dotsStyle: 'classy',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  modern: {\n    width: 300,\n    dotsStyle: 'extra-rounded',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#1a1a1a',\n    backgroundColor: '#ffffff',\n    margin: 2,\n  },\n};\n"]}

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

@@ -132,13 +132,13 @@ export class ThemeService {
                 break;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, providedIn: 'root' }); }
+    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: "17.3.12", ngImport: i0, type: ThemeService, decorators: [{
+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":["../../../../../projects/valtech-components/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  toggleTheme(name: string, shouldAdd: boolean) {\n    console.log('toggleTheme::: ', name, shouldAdd);\n    document.body.classList.toggle(name, shouldAdd);\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"]}
+//# 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  toggleTheme(name: string, shouldAdd: boolean) {\n    console.log('toggleTheme::: ', name, shouldAdd);\n    document.body.classList.toggle(name, shouldAdd);\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

@@ -35,13 +35,13 @@ export class ToastService {
             console.error(JSON.stringify(error));
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToastService, deps: [{ token: i1.ToastController }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToastService, providedIn: 'root' }); }
+    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: "17.3.12", ngImport: i0, type: ToastService, decorators: [{
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRlY2gtY29tcG9uZW50cy9zcmMvbGliL3NlcnZpY2VzL3RvYXN0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBRzNDOzs7R0FHRztBQUlILE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLFlBQW9CLGVBQWdDO1FBQWhDLG9CQUFlLEdBQWYsZUFBZSxDQUFpQjtJQUFHLENBQUM7SUFFeEQ7OztPQUdHO0lBQ0gsS0FBSyxDQUFDLFlBQVksQ0FBQyxPQUFxQjtRQUN0QyxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDO1lBQzlDLE9BQU8sRUFBRSxPQUFPLENBQUMsT0FBTztZQUN4QixRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVE7WUFDMUIsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO1lBQzFCLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSztTQUNyQixDQUFDLENBQUM7UUFFSCxNQUFNLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN4QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsSUFBSSxDQUFDLE9BQXFCO1FBQ3hCLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDO2FBQ3ZCLElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDVCxPQUFPLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ2hDLENBQUMsQ0FBQzthQUNELEtBQUssQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUNiLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ3ZDLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzsrR0E5QlUsWUFBWTttSEFBWixZQUFZLGNBRlgsTUFBTTs7NEZBRVAsWUFBWTtrQkFIeEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUb2FzdENvbnRyb2xsZXIsIFRvYXN0T3B0aW9ucyB9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcblxuLyoqXG4gKiBTZXJ2aWNlIGZvciBkaXNwbGF5aW5nIHRvYXN0IG5vdGlmaWNhdGlvbnMgdXNpbmcgSW9uaWMncyBUb2FzdENvbnRyb2xsZXIuXG4gKiBQcm92aWRlcyBtZXRob2RzIHRvIHNob3cgYW5kIHByZXNlbnQgdG9hc3RzIHdpdGggY3VzdG9tIG9wdGlvbnMuXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBUb2FzdFNlcnZpY2Uge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHRvYXN0Q29udHJvbGxlcjogVG9hc3RDb250cm9sbGVyKSB7fVxuXG4gIC8qKlxuICAgKiBQcmVzZW50cyBhIHRvYXN0IG5vdGlmaWNhdGlvbiB3aXRoIHRoZSBnaXZlbiBvcHRpb25zLlxuICAgKiBAcGFyYW0gcmVxdWVzdCBUb2FzdCBvcHRpb25zIChtZXNzYWdlLCBkdXJhdGlvbiwgcG9zaXRpb24sIGNvbG9yLCBldGMuKVxuICAgKi9cbiAgYXN5bmMgcHJlc2VudFRvYXN0KHJlcXVlc3Q6IFRvYXN0T3B0aW9ucykge1xuICAgIGNvbnN0IHRvYXN0ID0gYXdhaXQgdGhpcy50b2FzdENvbnRyb2xsZXIuY3JlYXRlKHtcbiAgICAgIG1lc3NhZ2U6IHJlcXVlc3QubWVzc2FnZSxcbiAgICAgIGR1cmF0aW9uOiByZXF1ZXN0LmR1cmF0aW9uLFxuICAgICAgcG9zaXRpb246IHJlcXVlc3QucG9zaXRpb24sXG4gICAgICBjb2xvcjogcmVxdWVzdC5jb2xvcixcbiAgICB9KTtcblxuICAgIGF3YWl0IHRvYXN0LnByZXNlbnQoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTaG93cyBhIHRvYXN0IG5vdGlmaWNhdGlvbiBhbmQgbG9ncyB0aGUgcmVzdWx0LlxuICAgKiBAcGFyYW0gcmVxdWVzdCBUb2FzdCBvcHRpb25zIChtZXNzYWdlLCBkdXJhdGlvbiwgcG9zaXRpb24sIGNvbG9yLCBldGMuKVxuICAgKi9cbiAgc2hvdyhyZXF1ZXN0OiBUb2FzdE9wdGlvbnMpIHtcbiAgICB0aGlzLnByZXNlbnRUb2FzdChyZXF1ZXN0KVxuICAgICAgLnRoZW4oKCkgPT4ge1xuICAgICAgICBjb25zb2xlLmluZm8oJ1RvYXN0IGNyZWF0ZWQnKTtcbiAgICAgIH0pXG4gICAgICAuY2F0Y2goZXJyb3IgPT4ge1xuICAgICAgICBjb25zb2xlLmVycm9yKEpTT04uc3RyaW5naWZ5KGVycm9yKSk7XG4gICAgICB9KTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/types.mjs

@@ -1,3 +1,3 @@
 import { InjectionToken } from '@angular/core';
 export const ValtechConfigService = new InjectionToken('ValtechConfig');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0ZWNoLWNvbXBvbmVudHMvc3JjL2xpYi9zZXJ2aWNlcy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBTy9DLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUFnQixlQUFlLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQcm92aWRlciB9IGZyb20gJy4vbGFuZy1wcm92aWRlci9jb250ZW50JztcblxuZXhwb3J0IGludGVyZmFjZSBWYWx0ZWNoQ29uZmlnIHtcbiAgY29udGVudDogUHJvdmlkZXI7XG59XG5cbmV4cG9ydCBjb25zdCBWYWx0ZWNoQ29uZmlnU2VydmljZSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxWYWx0ZWNoQ29uZmlnPignVmFsdGVjaENvbmZpZycpO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFPL0MsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxjQUFjLENBQWdCLGVBQWUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFByb3ZpZGVyIH0gZnJvbSAnLi9sYW5nLXByb3ZpZGVyL2NvbnRlbnQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFZhbHRlY2hDb25maWcge1xuICBjb250ZW50OiBQcm92aWRlcjtcbn1cblxuZXhwb3J0IGNvbnN0IFZhbHRlY2hDb25maWdTZXJ2aWNlID0gbmV3IEluamVjdGlvblRva2VuPFZhbHRlY2hDb25maWc+KCdWYWx0ZWNoQ29uZmlnJyk7XG4iXX0=

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

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

package/esm2022/lib/shared/pipes/process-links.pipe.mjs

@@ -56,14 +56,14 @@ export class ProcessLinksPipe {
         }
         return this.linkProcessor.processLinks(value, config);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProcessLinksPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ProcessLinksPipe, isStandalone: true, name: "processLinks" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, isStandalone: true, name: "processLinks" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProcessLinksPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'processLinks',
                     standalone: true,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1saW5rcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zaGFyZWQvcGlwZXMvcHJvY2Vzcy1saW5rcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU1RCxPQUFPLEVBQXVCLG9CQUFvQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7O0FBRWxHOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBNEJHO0FBS0gsTUFBTSxPQUFPLGdCQUFnQjtJQUo3QjtRQUtVLGtCQUFhLEdBQUcsTUFBTSxDQUFDLG9CQUFvQixDQUFDLENBQUM7S0F5QnREO0lBdkJDOzs7Ozs7Ozs7Ozs7Ozs7T0FlRztJQUNILFNBQVMsQ0FBQyxLQUFhLEVBQUUsTUFBNEI7UUFDbkQsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ1gsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDeEQsQ0FBQzsrR0F6QlUsZ0JBQWdCOzZHQUFoQixnQkFBZ0I7OzRGQUFoQixnQkFBZ0I7a0JBSjVCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLGNBQWM7b0JBQ3BCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU2FmZUh0bWwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcbmltcG9ydCB7IExpbmtQcm9jZXNzb3JDb25maWcsIExpbmtQcm9jZXNzb3JTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvbGluay1wcm9jZXNzb3Iuc2VydmljZSc7XG5cbi8qKlxuICogUHJvY2Vzc0xpbmtzUGlwZSAtIFBpcGUgcGFyYSBwcm9jZXNhciB0ZXh0byB5IGNvbnZlcnRpciBVUkxzIGVuIGVubGFjZXMgY2xpY2tlYWJsZXMuXG4gKlxuICogRXN0ZSBwaXBlIHN0YW5kYWxvbmUgZGV0ZWN0YSBhdXRvbcOhdGljYW1lbnRlIFVSTHMgZXh0ZXJuYXMgKGh0dHAvaHR0cHMpIHkgcnV0YXMgaW50ZXJuYXNcbiAqIChxdWUgZW1waWV6YW4gY29uIC8pIHkgbGFzIGNvbnZpZXJ0ZSBlbiBlbGVtZW50b3MgSFRNTCBhbmNob3IgY29uIGxvcyBhdHJpYnV0b3MgYXByb3BpYWRvcy5cbiAqXG4gKiBAZXhhbXBsZSBVc28gYsOhc2ljbzpcbiAqIGBgYGh0bWxcbiAqIDxkaXYgW2lubmVySFRNTF09XCInVmlzaXQgaHR0cHM6Ly9leGFtcGxlLmNvbSBvciBnbyB0byAvcHJvZmlsZScgfCBwcm9jZXNzTGlua3NcIj48L2Rpdj5cbiAqIGBgYFxuICpcbiAqIEBleGFtcGxlIENvbiBjb25maWd1cmFjacOzbiBwZXJzb25hbGl6YWRhOlxuICogYGBgaHRtbFxuICogPGRpdiBbaW5uZXJIVE1MXT1cInRleHQgfCBwcm9jZXNzTGlua3M6bGlua0NvbmZpZ1wiPjwvZGl2PlxuICogYGBgXG4gKlxuICogQGV4YW1wbGUgRW4gVHlwZVNjcmlwdDpcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGV4cG9ydCBjbGFzcyBNeUNvbXBvbmVudCB7XG4gKiAgIGxpbmtDb25maWc6IExpbmtQcm9jZXNzb3JDb25maWcgPSB7XG4gKiAgICAgb3BlbkV4dGVybmFsSW5OZXdUYWI6IHRydWUsXG4gKiAgICAgb3BlbkludGVybmFsSW5OZXdUYWI6IGZhbHNlLFxuICogICAgIGxpbmtDbGFzczogJ215LWxpbmsnLFxuICogICAgIGV4dGVybmFsTGlua0NsYXNzOiAnZXh0ZXJuYWwnLFxuICogICAgIGludGVybmFsTGlua0NsYXNzOiAnaW50ZXJuYWwnXG4gKiAgIH07XG4gKiB9XG4gKiBgYGBcbiAqL1xuQFBpcGUoe1xuICBuYW1lOiAncHJvY2Vzc0xpbmtzJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgUHJvY2Vzc0xpbmtzUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBwcml2YXRlIGxpbmtQcm9jZXNzb3IgPSBpbmplY3QoTGlua1Byb2Nlc3NvclNlcnZpY2UpO1xuXG4gIC8qKlxuICAgKiBUcmFuc2Zvcm1hIHRleHRvIHByb2Nlc2FuZG8gVVJMcyB5IHJ1dGFzIGludGVybmFzIHBhcmEgY29udmVydGlybGFzIGVuIGVubGFjZXMuXG4gICAqXG4gICAqIEBwYXJhbSB2YWx1ZSAtIEVsIHRleHRvIGEgcHJvY2VzYXJcbiAgICogQHBhcmFtIGNvbmZpZyAtIENvbmZpZ3VyYWNpw7NuIG9wY2lvbmFsIHBhcmEgZWwgcHJvY2VzYW1pZW50byBkZSBlbmxhY2VzXG4gICAqIEByZXR1cm5zIFNhZmVIdG1sIGNvbiBlbmxhY2VzIHByb2Nlc2Fkb3MgbyBzdHJpbmcgb3JpZ2luYWwgc2kgbm8gaGF5IGVubGFjZXNcbiAgICpcbiAgICogQGV4YW1wbGVcbiAgICogYGBgaHRtbFxuICAgKiA8IS0tIFVzbyBiw6FzaWNvIC0tPlxuICAgKiA8cCBbaW5uZXJIVE1MXT1cIidDaGVjayBvdXQgaHR0cHM6Ly9hbmd1bGFyLmlvJyB8IHByb2Nlc3NMaW5rc1wiPjwvcD5cbiAgICpcbiAgICogPCEtLSBDb24gY29uZmlndXJhY2nDs24gLS0+XG4gICAqIDxwIFtpbm5lckhUTUxdPVwibWVzc2FnZSB8IHByb2Nlc3NMaW5rczp7IG9wZW5FeHRlcm5hbEluTmV3VGFiOiBmYWxzZSB9XCI+PC9wPlxuICAgKiBgYGBcbiAgICovXG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nLCBjb25maWc/OiBMaW5rUHJvY2Vzc29yQ29uZmlnKTogU2FmZUh0bWwgfCBzdHJpbmcge1xuICAgIGlmICghdmFsdWUpIHtcbiAgICAgIHJldHVybiAnJztcbiAgICB9XG5cbiAgICByZXR1cm4gdGhpcy5saW5rUHJvY2Vzc29yLnByb2Nlc3NMaW5rcyh2YWx1ZSwgY29uZmlnKTtcbiAgfVxufVxuIl19