valtech-components 2.0.691 → 2.0.692

package/esm2022/lib/services/presets/preset.service.mjs

@@ -0,0 +1,104 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar presets de componentes.
+ *
+ * Los presets permiten definir configuraciones reutilizables
+ * de componentes (tamaño, color, variante, etc.) que se pueden
+ * aplicar con un nombre semántico.
+ *
+ * @example
+ * // En un componente
+ * presets = inject(PresetService);
+ *
+ * // Obtener preset
+ * const buttonProps = this.presets.get<ButtonMetadata>('button', 'primary-action');
+ * // { size: 'large', color: 'primary', fill: 'solid' }
+ */
+export class PresetService {
+    constructor() {
+        this._presets = signal({});
+    }
+    /**
+     * Obtiene un preset específico para un componente
+     *
+     * @param component Tipo de componente (ej: 'button', 'card', 'input')
+     * @param presetName Nombre del preset (ej: 'primary-action', 'compact')
+     * @returns Propiedades del preset o objeto vacío si no existe
+     *
+     * @example
+     * // Obtener preset de botón
+     * const props = presets.get<ButtonMetadata>('button', 'primary-action');
+     *
+     * // Usar en componente
+     * <val-button [props]="props"></val-button>
+     */
+    get(component, presetName) {
+        const componentPresets = this._presets()[component];
+        if (!componentPresets) {
+            console.warn(`[presets] No presets registered for component: ${component}`);
+            return {};
+        }
+        const preset = componentPresets[presetName];
+        if (!preset) {
+            console.warn(`[presets] Preset '${presetName}' not found for component: ${component}`);
+            return {};
+        }
+        return preset;
+    }
+    /**
+     * Verifica si existe un preset
+     */
+    has(component, presetName) {
+        return !!this._presets()[component]?.[presetName];
+    }
+    /**
+     * Registra presets de la aplicación
+     *
+     * @param presets Configuración de presets
+     *
+     * @example
+     * presets.registerPresets({
+     *   button: {
+     *     'primary-action': { size: 'large', color: 'primary' },
+     *   },
+     *   card: {
+     *     'feature': { variant: 'elevated' },
+     *   }
+     * });
+     */
+    registerPresets(presets) {
+        this._presets.set(presets);
+    }
+    /**
+     * Agrega presets para un componente específico (merge con existentes)
+     */
+    registerComponentPresets(component, presets) {
+        this._presets.update((current) => ({
+            ...current,
+            [component]: {
+                ...current[component],
+                ...presets,
+            },
+        }));
+    }
+    /**
+     * Obtiene todos los nombres de presets para un componente
+     */
+    getPresetNames(component) {
+        return Object.keys(this._presets()[component] || {});
+    }
+    /**
+     * Obtiene todos los componentes con presets registrados
+     */
+    getRegisteredComponents() {
+        return Object.keys(this._presets());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3ByZXNldHMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHJlc2V0cyBwYXJhIHVuIHRpcG8gZGUgY29tcG9uZW50ZVxuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBidXR0b25QcmVzZXRzOiBDb21wb25lbnRQcmVzZXRzID0ge1xuICogICAncHJpbWFyeS1hY3Rpb24nOiB7IHNpemU6ICdsYXJnZScsIGNvbG9yOiAncHJpbWFyeScsIGZpbGw6ICdzb2xpZCcgfSxcbiAqICAgJ3NlY29uZGFyeSc6IHsgc2l6ZTogJ21lZGl1bScsIGNvbG9yOiAnc2Vjb25kYXJ5JywgZmlsbDogJ291dGxpbmUnIH0sXG4gKiAgICdkYW5nZXInOiB7IHNpemU6ICdtZWRpdW0nLCBjb2xvcjogJ2RhbmdlcicsIGZpbGw6ICdzb2xpZCcgfSxcbiAqIH07XG4gKi9cbmV4cG9ydCB0eXBlIENvbXBvbmVudFByZXNldHMgPSBSZWNvcmQ8c3RyaW5nLCBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj47XG5cbi8qKlxuICogQ29uZmlndXJhY2nDs24gY29tcGxldGEgZGUgcHJlc2V0cyBwb3IgY29tcG9uZW50ZVxuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBhcHBQcmVzZXRzOiBQcmVzZXRDb25maWcgPSB7XG4gKiAgIGJ1dHRvbjoge1xuICogICAgICdwcmltYXJ5LWFjdGlvbic6IHsgc2l6ZTogJ2xhcmdlJywgY29sb3I6ICdwcmltYXJ5JywgZmlsbDogJ3NvbGlkJyB9LFxuICogICAgICdzZWNvbmRhcnknOiB7IHNpemU6ICdtZWRpdW0nLCBjb2xvcjogJ3NlY29uZGFyeScsIGZpbGw6ICdvdXRsaW5lJyB9LFxuICogICB9LFxuICogICBjYXJkOiB7XG4gKiAgICAgJ2ZlYXR1cmUnOiB7IHZhcmlhbnQ6ICdlbGV2YXRlZCcsIHBhZGRpbmc6ICdsYXJnZScgfSxcbiAqICAgICAnY29tcGFjdCc6IHsgdmFyaWFudDogJ2ZsYXQnLCBwYWRkaW5nOiAnc21hbGwnIH0sXG4gKiAgIH0sXG4gKiAgIGlucHV0OiB7XG4gKiAgICAgJ2Zvcm0tZmllbGQnOiB7IHNpemU6ICdtZWRpdW0nLCBmaWxsOiAnb3V0bGluZScsIGxhYmVsUG9zaXRpb246ICdmbG9hdGluZycgfSxcbiAqICAgfVxuICogfTtcbiAqL1xuZXhwb3J0IHR5cGUgUHJlc2V0Q29uZmlnID0gUmVjb3JkPHN0cmluZywgQ29tcG9uZW50UHJlc2V0cz47XG5cbi8qKlxuICogT3BjaW9uZXMgcGFyYSBwcm92aWRlVmFsdGVjaFByZXNldHMoKVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFByZXNldHNPcHRpb25zIHtcbiAgLyoqXG4gICAqIFByZXNldHMgaW5pY2lhbGVzIGRlIGxhIGFwbGljYWNpw7NuXG4gICAqL1xuICBwcmVzZXRzOiBQcmVzZXRDb25maWc7XG59XG4iXX0=

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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAOL,UAAU,GACX,MAAM,SAAS,CAAC;;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,QAAQ,CAAC,MAAgB;QAE7B,sBAAsB;QACtB,MAAM,WAAW,GAAa;YAC5B,KAAK,EAAE,GAAG;YACV,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,IAAI,GAAG;YAC5C,MAAM,EAAE,CAAC;YACT,SAAS,EAAE,QAAQ;YACnB,SAAS,EAAE,SAAS;YACpB,eAAe,EAAE,SAAS;YAC1B,oBAAoB,EAAE,GAAG;YACzB,MAAM,EAAE,KAAK;YACb,OAAO,EAAE,CAAC;YACV,GAAG,MAAM;SACV,CAAC;QAEF,gCAAgC;QAChC,MAAM,SAAS,GAAQ;YACrB,KAAK,EAAE,WAAW,CAAC,KAAK;YACxB,MAAM,EAAE,WAAW,CAAC,MAAM;YAC1B,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,MAAM,EAAE,WAAW,CAAC,MAAM;YAC1B,SAAS,EAAE;gBACT,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;aACvD;YACD,WAAW,EAAE;gBACX,IAAI,EAAE,WAAW,CAAC,SAAS;gBAC3B,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,SAAS,CAAC;aACjD;YACD,iBAAiB,EAAE;gBACjB,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,eAAe,CAAC;aACvD;YACD,oBAAoB,EAAE,WAAW,CAAC,kBAAkB,IAAI,WAAW,CAAC,kBAAkB;gBACpF,CAAC,CAAC;oBACE,IAAI,EAAE,WAAW,CAAC,kBAAkB;oBACpC,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,kBAAkB,IAAI,WAAW,CAAC,SAAS,CAAC;iBACnF;gBACH,CAAC,CAAC,SAAS;YACb,iBAAiB,EAAE,WAAW,CAAC,eAAe,IAAI,WAAW,CAAC,eAAe;gBAC3E,CAAC,CAAC;oBACE,IAAI,EAAE,WAAW,CAAC,eAAe;oBACjC,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,eAAe,IAAI,WAAW,CAAC,SAAS,CAAC;iBAChF;gBACH,CAAC,CAAC,SAAS;SACd,CAAC;QAEF,uBAAuB;QACvB,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC;YACrB,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC;YACvC,SAAS,CAAC,YAAY,GAAG;gBACvB,kBAAkB,EAAE,WAAW,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI;gBAC/D,SAAS,EAAE,GAAG;gBACd,MAAM,EAAE,WAAW,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC;gBACpC,WAAW,EAAE,WAAW;aACzB,CAAC;QACJ,CAAC;QAED,0BAA0B;QAC1B,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;QAE5C,gBAAgB;QAChB,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,IAAI,KAAK,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC1C,MAAM,SAAS,GAAG,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAErD,IAAI,IAAU,CAAC;QACf,IAAI,GAAuB,CAAC;QAC5B,IAAI,OAAe,CAAC;QAEpB,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;YACrB,eAAe;YACf,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAC5C,CAAC;YACD,IAAI,GAAG,OAAe,CAAC;YACvB,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;YACxB,OAAO,GAAG,QAAQ,QAAQ,WAAW,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACnD,CAAC;aAAM,CAAC;YACN,iBAAiB;YACjB,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,MAAiC,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAC9C,CAAC;YACD,IAAI,GAAG,SAAiB,CAAC;YACzB,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO;YACL,MAAM,EAAE,WAAW;YACnB,OAAO;YACP,IAAI;YACJ,GAAG;YACH,QAAQ;YACR,SAAS;YACT,WAAW,EAAE,IAAI,IAAI,EAAE;SACxB,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,kBAAkB,CACtB,MAAwC,EACxC,IAAY,EACZ,SAA6B;QAE7B,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,QAAQ,CAAC;YACnB,GAAG,YAAY;YACf,GAAG,SAAS;YACZ,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAY,EAAE,OAA2B;QACtD,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,WAAW,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAC9D,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,EAAE,CAAC,MAAM,CAAC,MAAM,IAAI,KAAK,CAAC;QAC5D,MAAM,SAAS,GAAG,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAErD,IAAI,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;QAEnB,wCAAwC;QACxC,IAAI,OAAO,EAAE,MAAM,IAAI,OAAO,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YAC3D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC;gBAChC,GAAG,EAAE,CAAC,MAAM;gBACZ,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;YACH,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QACpB,CAAC;QAED,uBAAuB;QACvB,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,QAAQ,GAAG,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC;QAC3C,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAChC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,EAAY;QAChC,IAAI,CAAC;YACH,oCAAoC;YACpC,IAAI,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC;YAEtB,IAAI,EAAE,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;gBAChC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC;oBAChC,GAAG,EAAE,CAAC,MAAM;oBACZ,MAAM,EAAE,KAAK;iBACd,CAAC,CAAC;gBACH,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC;YACvB,CAAC;YAED,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC;gBAC9B,IAAI,aAAa,CAAC;oBAChB,WAAW,EAAE,OAAO;iBACrB,CAAC;aACH,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,iCAAiC,EAAE,KAAK,CAAC,CAAC;YACxD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,CAAC,EAAY,EAAE,OAAwB;QAChD,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;YAC5C,OAAO,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;YAC5C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,WAAW,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,SAAS,EAAE,CAAC;YAC9E,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;YAElE,MAAM,SAAS,GAAc;gBAC3B,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,SAAS;gBAClC,IAAI,EAAE,OAAO,EAAE,IAAI;gBACnB,KAAK,EAAE,CAAC,IAAI,CAAC;aACd,CAAC;YAEF,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;gBAClC,MAAM,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBACjC,OAAO,IAAI,CAAC;YACd,CAAC;YAED,wBAAwB;YACxB,MAAM,SAAS,CAAC,KAAK,CAAC;gBACpB,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,SAAS;gBAClC,IAAI,EAAE,OAAO,EAAE,IAAI;aACpB,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAAe,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC3C,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;YAC9C,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,EAAY;QACnB,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC,QAAQ,UAAU,CAAC;QAC7C,IAAI,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAClC,OAAO,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO,EAAE,CAAC,OAAO,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,EAAY;QACpB,OAAO,EAAE,CAAC,OAAO,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAY;QACjB,OAAO,EAAE,CAAC,IAAI,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9D,CAAC;IAED,0BAA0B;IAElB,iBAAiB,CAAC,KAAqB;QAC7C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,EAAE,KAAK,EAAE,CAAC;QACnB,CAAC;QAED,WAAW;QACX,MAAM,QAAQ,GAAG,KAAmB,CAAC;QACrC,OAAO;YACL,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,CAAC;gBAChC,UAAU,EAAE,QAAQ,CAAC,UAAU;aAChC;SACF,CAAC;IACJ,CAAC;IAEO,WAAW,CAAC,MAAc;QAChC,MAAM,SAAS,GAA2B;YACxC,GAAG,EAAE,WAAW;YAChB,IAAI,EAAE,YAAY;YAClB,IAAI,EAAE,YAAY;YAClB,GAAG,EAAE,eAAe;SACrB,CAAC;QACF,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC;IAC1C,CAAC;IAEO,aAAa,CAAC,IAAU;QAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAChC,MAAM,CAAC,SAAS,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAgB,CAAC,CAAC;YAC1D,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC;YACxB,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;+GA7UU,kBAAkB;mHAAlB,kBAAkB,cAFjB,MAAM;;4FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","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/skeleton/config.mjs

@@ -0,0 +1,79 @@
+import { makeEnvironmentProviders, APP_INITIALIZER } from '@angular/core';
+import { DEFAULT_SKELETON_CONFIG } from './types';
+import { SkeletonService } from './skeleton.service';
+// Import built-in templates
+import { ListSkeletonComponent } from './templates/list-skeleton.component';
+import { GridSkeletonComponent } from './templates/grid-skeleton.component';
+import { FormSkeletonComponent } from './templates/form-skeleton.component';
+import { ProfileSkeletonComponent } from './templates/profile-skeleton.component';
+import { TableSkeletonComponent } from './templates/table-skeleton.component';
+import { DetailSkeletonComponent } from './templates/detail-skeleton.component';
+/**
+ * Configura el sistema de skeletons para Valtech Components.
+ *
+ * @param config Configuracion de skeletons
+ * @returns Providers para app.config.ts
+ *
+ * @example
+ * // app.config.ts
+ * import { provideValtechSkeleton } from 'valtech-components';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideValtechSkeleton({
+ *       animated: true,
+ *       defaultDelay: 100,
+ *       defaultMinTime: 500,
+ *       templates: [
+ *         { name: 'custom-card', component: MyCustomCardSkeleton }
+ *       ]
+ *     }),
+ *   ]
+ * };
+ *
+ * @example
+ * // Uso minimo - usa configuracion por defecto
+ * providers: [provideValtechSkeleton()]
+ */
+export function provideValtechSkeleton(config = {}) {
+    const mergedConfig = { ...DEFAULT_SKELETON_CONFIG, ...config };
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (skeletonService) => {
+                return () => {
+                    // Configurar servicio
+                    skeletonService.configure(mergedConfig);
+                    // Registrar templates built-in
+                    skeletonService.registerTemplate('list', ListSkeletonComponent, { count: 3 });
+                    skeletonService.registerTemplate('list-avatar', ListSkeletonComponent, {
+                        count: 3,
+                        variant: 'avatar',
+                    });
+                    skeletonService.registerTemplate('grid', GridSkeletonComponent, { count: 4 });
+                    skeletonService.registerTemplate('grid-cards', GridSkeletonComponent, {
+                        count: 6,
+                        variant: 'cards',
+                    });
+                    skeletonService.registerTemplate('form', FormSkeletonComponent, { count: 3 });
+                    skeletonService.registerTemplate('form-compact', FormSkeletonComponent, {
+                        count: 2,
+                        variant: 'compact',
+                    });
+                    skeletonService.registerTemplate('profile', ProfileSkeletonComponent, {});
+                    skeletonService.registerTemplate('profile-full', ProfileSkeletonComponent, {
+                        variant: 'full',
+                    });
+                    skeletonService.registerTemplate('table', TableSkeletonComponent, {
+                        columns: 4,
+                        rows: 5,
+                    });
+                    skeletonService.registerTemplate('detail', DetailSkeletonComponent, { sections: 2 });
+                };
+            },
+            deps: [SkeletonService],
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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